- wine-devel - winehq.org

[PATCH 1/5] dxgi: Simplify dxgi_adapter_GetDesc().
by Józef Kucia 25 Sep '18

25 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/dxgi/adapter.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/dlls/dxgi/adapter.c b/dlls/dxgi/adapter.c index b7d7a0a65aae..1f81d7717e1b 100644 --- a/dlls/dxgi/adapter.c +++ b/dlls/dxgi/adapter.c @@ -200,9 +200,8 @@ static HRESULT STDMETHODCALLTYPE dxgi_adapter_GetDesc(IWineDXGIAdapter *iface, D if (!desc) return E_INVALIDARG; - if (FAILED(hr = dxgi_adapter_GetDesc1(iface, &desc1))) - return hr; - memcpy(desc, &desc1, sizeof(*desc)); + if (SUCCEEDED(hr = dxgi_adapter_GetDesc1(iface, &desc1))) + memcpy(desc, &desc1, sizeof(*desc)); return hr; } -- 2.16.4

2 1

[PATCH vkd3d 7/9] vkd3d: Add WARN() for "out of device memory" errors.
by Józef Kucia 25 Sep '18

25 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/utils.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/libs/vkd3d/utils.c b/libs/vkd3d/utils.c index 682822e8b89a..05d15b2ccd62 100644 --- a/libs/vkd3d/utils.c +++ b/libs/vkd3d/utils.c @@ -387,8 +387,9 @@ HRESULT hresult_from_vk_result(VkResult vr) { case VK_SUCCESS: return S_OK; - case VK_ERROR_OUT_OF_HOST_MEMORY: case VK_ERROR_OUT_OF_DEVICE_MEMORY: + WARN("Out of device memory.\n"); + case VK_ERROR_OUT_OF_HOST_MEMORY: return E_OUTOFMEMORY; default: FIXME("Unhandled VkResult %d.\n", vr); -- 2.16.4

2 1

[PATCH vkd3d 9/9] tests: Add test for GetResourceAllocationInfo().
by Józef Kucia 25 Sep '18

25 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- tests/d3d12.c | 74 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) diff --git a/tests/d3d12.c b/tests/d3d12.c index 61030104038d..69b9fe7f0284 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -19558,6 +19558,79 @@ static void test_combined_clip_and_cull_distances(void) destroy_test_context(&context); } +static void test_resource_allocation_info(void) +{ + D3D12_RESOURCE_ALLOCATION_INFO info; + D3D12_RESOURCE_DESC desc; + ID3D12Device *device; + unsigned int i, j; + ULONG refcount; + + static const unsigned int alignments[] = + { + 0, + D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT, + D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT, + D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT, + }; + static const unsigned int buffer_sizes[] = + { + 1, + 16, + 256, + 1024, + D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT, + D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT + 1, + D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT, + D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT + 1, + D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT, + D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT + 1, + }; + + if (!(device = create_device())) + { + skip("Failed to create device.\n"); + return; + } + + desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER; + desc.Alignment = 0; + desc.Width = 32; + desc.Height = 1; + desc.DepthOrArraySize = 1; + desc.MipLevels = 1; + desc.Format = DXGI_FORMAT_UNKNOWN; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; + desc.Flags = 0; + + for (i = 0; i < ARRAY_SIZE(alignments); ++i) + { + for (j = 0; j < ARRAY_SIZE(buffer_sizes); ++j) + { + desc.Alignment = alignments[i]; + desc.Width = buffer_sizes[j]; + info = ID3D12Device_GetResourceAllocationInfo(device, 0, 1, &desc); + if (!desc.Alignment || desc.Alignment == D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT) + { + check_alignment(info.SizeInBytes, info.Alignment); + } + else + { + ok(info.SizeInBytes == ~(UINT64)0, + "Got unexpected size %"PRIu64".\n", info.SizeInBytes); + ok(info.Alignment == D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT, + "Got unexpected alignment %"PRIu64".\n", info.Alignment); + } + } + } + + + refcount = ID3D12Device_Release(device); + ok(!refcount, "ID3D12Device has %u references left.\n", (unsigned int)refcount); +} + static void test_suballocate_small_textures(void) { D3D12_GPU_VIRTUAL_ADDRESS gpu_address; @@ -19758,5 +19831,6 @@ START_TEST(d3d12) run_test(test_cpu_descriptors_lifetime); run_test(test_clip_distance); run_test(test_combined_clip_and_cull_distances); + run_test(test_resource_allocation_info); run_test(test_suballocate_small_textures); } -- 2.16.4

2 1

[PATCH vkd3d 8/9] tests: Add test for suballocation of small textures.
by Józef Kucia 25 Sep '18

25 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- tests/d3d12.c | 92 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 92 insertions(+) diff --git a/tests/d3d12.c b/tests/d3d12.c index 5f2d2d8e50bf..61030104038d 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -193,6 +193,14 @@ static void check_heap_desc_(unsigned int line, const D3D12_HEAP_DESC *desc, "Got flags %#x, expected %#x.\n", desc->Flags, expected.Flags); } +#define check_alignment(a, b) check_alignment_(__LINE__, a, b) +static void check_alignment_(unsigned int line, uint64_t size, uint64_t alignment) +{ + uint64_t aligned_size = align(size, alignment); + ok_(line)(aligned_size == size, "Got unaligned size %"PRIu64", expected %"PRIu64".\n", + size, aligned_size); +} + static void uav_barrier(ID3D12GraphicsCommandList *list, ID3D12Resource *resource) { D3D12_RESOURCE_BARRIER barrier; @@ -19550,6 +19558,89 @@ static void test_combined_clip_and_cull_distances(void) destroy_test_context(&context); } +static void test_suballocate_small_textures(void) +{ + D3D12_GPU_VIRTUAL_ADDRESS gpu_address; + D3D12_RESOURCE_ALLOCATION_INFO info; + D3D12_RESOURCE_DESC resource_desc; + ID3D12Resource *textures[10]; + D3D12_HEAP_DESC heap_desc; + ID3D12Device *device; + ID3D12Heap *heap; + unsigned int i; + ULONG refcount; + HRESULT hr; + + if (!(device = create_device())) + { + skip("Failed to create device.\n"); + return; + } + + resource_desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; + resource_desc.Alignment = 0; + resource_desc.Width = 32; + resource_desc.Height = 32; + resource_desc.DepthOrArraySize = 1; + resource_desc.MipLevels = 1; + resource_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + resource_desc.SampleDesc.Count = 1; + resource_desc.SampleDesc.Quality = 0; + resource_desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; + resource_desc.Flags = 0; + + resource_desc.Alignment = D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT; + + info = ID3D12Device_GetResourceAllocationInfo(device, 0, 1, &resource_desc); + trace("Size %"PRIu64", alignment %"PRIu64".\n", info.SizeInBytes, info.Alignment); + check_alignment(info.SizeInBytes, info.Alignment); + if (info.Alignment != D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT) + { + resource_desc.Alignment = 0; + info = ID3D12Device_GetResourceAllocationInfo(device, 0, 1, &resource_desc); + trace("Size %"PRIu64", alignment %"PRIu64".\n", info.SizeInBytes, info.Alignment); + check_alignment(info.SizeInBytes, info.Alignment); + } + + heap_desc.SizeInBytes = ARRAY_SIZE(textures) * info.SizeInBytes; + memset(&heap_desc.Properties, 0, sizeof(heap_desc.Properties)); + heap_desc.Properties.Type = D3D12_HEAP_TYPE_DEFAULT; + heap_desc.Alignment = 0; + heap_desc.Flags = D3D12_HEAP_FLAG_DENY_BUFFERS | D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES; + hr = ID3D12Device_CreateHeap(device, &heap_desc, &IID_ID3D12Heap, (void **)&heap); + ok(hr == S_OK, "Failed to create heap, hr %#x.\n", hr); + + for (i = 0; i < ARRAY_SIZE(textures); ++i) + { + hr = ID3D12Device_CreatePlacedResource(device, heap, i * info.SizeInBytes, + &resource_desc, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, + NULL, &IID_ID3D12Resource, (void **)&textures[i]); + ok(hr == S_OK, "Failed to create placed resource %u, hr %#x.\n", i, hr); + + check_interface(textures[i], &IID_ID3D12Object, TRUE); + check_interface(textures[i], &IID_ID3D12DeviceChild, TRUE); + check_interface(textures[i], &IID_ID3D12Pageable, TRUE); + check_interface(textures[i], &IID_ID3D12Resource, TRUE); + + gpu_address = ID3D12Resource_GetGPUVirtualAddress(textures[i]); + ok(!gpu_address, "Got unexpected GPU virtual address %#"PRIx64".\n", gpu_address); + } + + refcount = get_refcount(heap); + ok(refcount == 1, "Got unexpected refcount %u.\n", (unsigned int)refcount); + + for (i = 0; i < ARRAY_SIZE(textures); ++i) + { + refcount = ID3D12Resource_Release(textures[i]); + ok(!refcount, "ID3D12Resource has %u references left.\n", (unsigned int)refcount); + } + + refcount = ID3D12Heap_Release(heap); + ok(!refcount, "ID3D12Heap has %u references left.\n", (unsigned int)refcount); + refcount = ID3D12Device_Release(device); + ok(!refcount, "ID3D12Device has %u references left.\n", (unsigned int)refcount); +} + START_TEST(d3d12) { bool enable_debug_layer = false; @@ -19667,4 +19758,5 @@ START_TEST(d3d12) run_test(test_cpu_descriptors_lifetime); run_test(test_clip_distance); run_test(test_combined_clip_and_cull_distances); + run_test(test_suballocate_small_textures); } -- 2.16.4

2 1

[PATCH vkd3d 5/9] vkd3d: Allocate device memory for heaps.
by Józef Kucia 25 Sep '18

25 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/resource.c | 158 ++++++++++++++++++++++++--------------------- libs/vkd3d/vkd3d_private.h | 2 + 2 files changed, 87 insertions(+), 73 deletions(-) diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index 82ff701037a3..272fa70585f7 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -18,6 +18,79 @@ #include "vkd3d_private.h" +static unsigned int vkd3d_select_memory_type(struct d3d12_device *device, uint32_t memory_type_mask, + const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags) +{ + VkPhysicalDeviceMemoryProperties *memory_info = &device->memory_properties; + VkMemoryPropertyFlags required_flags; + unsigned int i; + + switch (heap_properties->Type) + { + case D3D12_HEAP_TYPE_DEFAULT: + required_flags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; + break; + + case D3D12_HEAP_TYPE_CUSTOM: + FIXME("Custom heaps not supported yet.\n"); + /* fall-through */ + case D3D12_HEAP_TYPE_UPLOAD: + case D3D12_HEAP_TYPE_READBACK: + required_flags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; + break; + + default: + WARN("Invalid heap type %#x.\n", heap_properties->Type); + return ~0u; + } + + for (i = 0; i < memory_info->memoryTypeCount; ++i) + { + if (!(memory_type_mask & (1u << i))) + continue; + if ((memory_info->memoryTypes[i].propertyFlags & required_flags) == required_flags) + return i; + } + + return ~0u; +} + +static HRESULT vkd3d_allocate_device_memory(struct d3d12_device *device, + const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, + const VkMemoryRequirements *memory_requirements, VkDeviceMemory *vk_memory) +{ + const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; + VkMemoryAllocateInfo allocate_info; + VkResult vr; + + TRACE("Memory requirements: size %#"PRIx64", alignment %#"PRIx64".\n", + memory_requirements->size, memory_requirements->alignment); + + allocate_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + allocate_info.pNext = NULL; + allocate_info.allocationSize = memory_requirements->size; + allocate_info.memoryTypeIndex = vkd3d_select_memory_type(device, + memory_requirements->memoryTypeBits, heap_properties, heap_flags); + + if (allocate_info.memoryTypeIndex == ~0u) + { + FIXME("Failed to find suitable memory type (allowed types %#x).\n", memory_requirements->memoryTypeBits); + *vk_memory = VK_NULL_HANDLE; + return E_FAIL; + } + + TRACE("Allocating memory type %u.\n", allocate_info.memoryTypeIndex); + + if ((vr = VK_CALL(vkAllocateMemory(device->vk_device, &allocate_info, NULL, vk_memory))) < 0) + { + WARN("Failed to allocate device memory, vr %d.\n", vr); + *vk_memory = VK_NULL_HANDLE; + return hresult_from_vk_result(vr); + } + + return S_OK; +} + /* ID3D12Heap */ static inline struct d3d12_heap *impl_from_ID3D12Heap(ID3D12Heap *iface) { @@ -66,6 +139,9 @@ static ULONG STDMETHODCALLTYPE d3d12_heap_Release(ID3D12Heap *iface) if (!refcount) { struct d3d12_device *device = heap->device; + const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; + + VK_CALL(vkFreeMemory(device->vk_device, heap->vk_memory, NULL)); vkd3d_free(heap); @@ -181,6 +257,7 @@ static HRESULT validate_heap_desc(const D3D12_HEAP_DESC *desc) static HRESULT d3d12_heap_init(struct d3d12_heap *heap, struct d3d12_device *device, const D3D12_HEAP_DESC *desc) { + VkMemoryRequirements memory_requirements; HRESULT hr; heap->ID3D12Heap_iface.lpVtbl = &d3d12_heap_vtbl; @@ -202,6 +279,14 @@ static HRESULT d3d12_heap_init(struct d3d12_heap *heap, if (FAILED(hr = validate_heap_desc(&heap->desc))) return hr; + memory_requirements.size = heap->desc.SizeInBytes; + memory_requirements.alignment = heap->desc.Alignment; + memory_requirements.memoryTypeBits = ~(uint32_t)0; + + if (FAILED(hr = vkd3d_allocate_device_memory(device, &heap->desc.Properties, + heap->desc.Flags, &memory_requirements, &heap->vk_memory))) + return hr; + heap->device = device; ID3D12Device_AddRef(&device->ID3D12Device_iface); @@ -433,79 +518,6 @@ HRESULT vkd3d_get_image_allocation_info(struct d3d12_device *device, return hr; } -static unsigned int vkd3d_select_memory_type(struct d3d12_device *device, uint32_t memory_type_mask, - const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags) -{ - VkPhysicalDeviceMemoryProperties *memory_info = &device->memory_properties; - VkMemoryPropertyFlags required_flags; - unsigned int i; - - switch (heap_properties->Type) - { - case D3D12_HEAP_TYPE_DEFAULT: - required_flags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; - break; - - case D3D12_HEAP_TYPE_CUSTOM: - FIXME("Custom heaps not supported yet.\n"); - /* fall-through */ - case D3D12_HEAP_TYPE_UPLOAD: - case D3D12_HEAP_TYPE_READBACK: - required_flags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; - break; - - default: - WARN("Invalid heap type %#x.\n", heap_properties->Type); - return ~0u; - } - - for (i = 0; i < memory_info->memoryTypeCount; ++i) - { - if (!(memory_type_mask & (1u << i))) - continue; - if ((memory_info->memoryTypes[i].propertyFlags & required_flags) == required_flags) - return i; - } - - return ~0u; -} - -static HRESULT vkd3d_allocate_device_memory(struct d3d12_device *device, - const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, - const VkMemoryRequirements *memory_requirements, VkDeviceMemory *vk_memory) -{ - const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; - VkMemoryAllocateInfo allocate_info; - VkResult vr; - - TRACE("Memory requirements: size %#"PRIx64", alignment %#"PRIx64".\n", - memory_requirements->size, memory_requirements->alignment); - - allocate_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; - allocate_info.pNext = NULL; - allocate_info.allocationSize = memory_requirements->size; - allocate_info.memoryTypeIndex = vkd3d_select_memory_type(device, - memory_requirements->memoryTypeBits, heap_properties, heap_flags); - - if (allocate_info.memoryTypeIndex == ~0u) - { - FIXME("Failed to find suitable memory type (allowed types %#x).\n", memory_requirements->memoryTypeBits); - *vk_memory = VK_NULL_HANDLE; - return E_FAIL; - } - - TRACE("Allocating memory type %u.\n", allocate_info.memoryTypeIndex); - - if ((vr = VK_CALL(vkAllocateMemory(device->vk_device, &allocate_info, NULL, vk_memory))) < 0) - { - WARN("Failed to allocate device memory, vr %d.\n", vr); - *vk_memory = VK_NULL_HANDLE; - return hresult_from_vk_result(vr); - } - - return S_OK; -} - HRESULT vkd3d_allocate_buffer_memory(struct d3d12_device *device, VkBuffer vk_buffer, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, VkDeviceMemory *vk_memory) diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 189ee4324ef5..4865671dd0dc 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -190,6 +190,8 @@ struct d3d12_heap D3D12_HEAP_DESC desc; + VkDeviceMemory vk_memory; + struct d3d12_device *device; }; -- 2.16.4

2 1

[PATCH vkd3d 4/9] vkd3d: Implement d3d12_device_GetResourceAllocationInfo() for textures.
by Józef Kucia 25 Sep '18

25 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> In Vulkan, we have to create an image to get its memory requirements. It would be very helpful if we could get the memory requirements without creating a resource. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- E.g. something along the lines of vkGetImageInfoMemoryRequirementsEXT(). --- libs/vkd3d/device.c | 38 ++++++++++++++++++++++++++++++++++---- libs/vkd3d/resource.c | 24 ++++++++++++++++++++++++ libs/vkd3d/vkd3d_private.h | 16 +++++++++------- 3 files changed, 67 insertions(+), 11 deletions(-) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 54196acb83e8..8cc61420bab9 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -2025,7 +2025,10 @@ static D3D12_RESOURCE_ALLOCATION_INFO * STDMETHODCALLTYPE d3d12_device_GetResour ID3D12Device *iface, D3D12_RESOURCE_ALLOCATION_INFO *info, UINT visible_mask, UINT count, const D3D12_RESOURCE_DESC *resource_descs) { + UINT64 default_alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT; + struct d3d12_device *device = impl_from_ID3D12Device(iface); const D3D12_RESOURCE_DESC *desc; + bool valid = true; TRACE("iface %p, info %p, visible_mask 0x%08x, count %u, resource_descs %p.\n", iface, info, visible_mask, count, resource_descs); @@ -2042,22 +2045,49 @@ static D3D12_RESOURCE_ALLOCATION_INFO * STDMETHODCALLTYPE d3d12_device_GetResour } desc = &resource_descs[0]; + + if (FAILED(d3d12_resource_validate_desc(desc))) + { + WARN("Invalid resource desc.\n"); + valid = false; + } + if (desc->Dimension == D3D12_RESOURCE_DIMENSION_BUFFER) { - info->SizeInBytes = align(desc->Width, D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT); + info->SizeInBytes = desc->Width; info->Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT; } else { - FIXME("Unhandled dimension %#x.\n", desc->Dimension); + if (desc->SampleDesc.Count != 1) + default_alignment = D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT; + + if (valid && FAILED(vkd3d_get_image_allocation_info(device, desc, info))) + { + WARN("Failed to get allocation info for texture.\n"); + valid = false; + } } - if (FAILED(d3d12_resource_validate_desc(desc))) + if (desc->Alignment % info->Alignment) + { + WARN("Invalid resource alignment %#"PRIx64" (required %#"PRIx64").\n", + desc->Alignment, info->Alignment); + valid = false; + } + + if (valid) + { + info->SizeInBytes = align(info->SizeInBytes, info->Alignment); + } + else { - WARN("Invalid resource desc.\n"); info->SizeInBytes = ~(UINT64)0; + info->Alignment = default_alignment; } + TRACE("Size %#"PRIx64", alignment %#"PRIx64".\n", info->SizeInBytes, info->Alignment); + return info; } diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index d5690deebb8e..82ff701037a3 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -409,6 +409,30 @@ static HRESULT vkd3d_create_image(struct d3d12_device *device, return S_OK; } +HRESULT vkd3d_get_image_allocation_info(struct d3d12_device *device, + const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_ALLOCATION_INFO *allocation_info) +{ + static const D3D12_HEAP_PROPERTIES heap_properties = {D3D12_HEAP_TYPE_DEFAULT}; + const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; + VkMemoryRequirements requirements; + VkImage vk_image; + HRESULT hr; + + assert(desc->Dimension != D3D12_RESOURCE_DIMENSION_BUFFER); + + /* XXX: We have to create an image to get its memory requirements. */ + if (SUCCEEDED(hr = vkd3d_create_image(device, &heap_properties, 0, desc, &vk_image))) + { + VK_CALL(vkGetImageMemoryRequirements(device->vk_device, vk_image, &requirements)); + VK_CALL(vkDestroyImage(device->vk_device, vk_image, NULL)); + + allocation_info->SizeInBytes = requirements.size; + allocation_info->Alignment = requirements.alignment; + } + + return hr; +} + static unsigned int vkd3d_select_memory_type(struct d3d12_device *device, uint32_t memory_type_mask, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags) { diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index c4d6dd531728..189ee4324ef5 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -251,6 +251,15 @@ HRESULT d3d12_placed_resource_create(struct d3d12_device *device, struct d3d12_h const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) DECLSPEC_HIDDEN; struct d3d12_resource *unsafe_impl_from_ID3D12Resource(ID3D12Resource *iface) DECLSPEC_HIDDEN; +HRESULT vkd3d_allocate_buffer_memory(struct d3d12_device *device, VkBuffer vk_buffer, + const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, + VkDeviceMemory *vk_memory) DECLSPEC_HIDDEN; +HRESULT vkd3d_create_buffer(struct d3d12_device *device, + const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, + const D3D12_RESOURCE_DESC *desc, VkBuffer *vk_buffer) DECLSPEC_HIDDEN; +HRESULT vkd3d_get_image_allocation_info(struct d3d12_device *device, + const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_ALLOCATION_INFO *allocation_info) DECLSPEC_HIDDEN; + struct vkd3d_view { LONG refcount; @@ -773,13 +782,6 @@ VkPipeline d3d12_device_find_cached_pipeline(struct d3d12_device *device, bool d3d12_device_put_pipeline_to_cache(struct d3d12_device *device, const struct vkd3d_pipeline_key *key, VkPipeline vk_pipeline, struct list *list) DECLSPEC_HIDDEN; -HRESULT vkd3d_create_buffer(struct d3d12_device *device, - const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, - const D3D12_RESOURCE_DESC *desc, VkBuffer *vk_buffer) DECLSPEC_HIDDEN; -HRESULT vkd3d_allocate_buffer_memory(struct d3d12_device *device, VkBuffer vk_buffer, - const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, - VkDeviceMemory *vk_memory) DECLSPEC_HIDDEN; - /* utils */ struct vkd3d_format { -- 2.16.4

2 1

[PATCH vkd3d 1/9] vkd3d: Add support for fake placed resources.
by Józef Kucia 25 Sep '18

25 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> Placed resources are not allocated from a given heap yet. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/device.c | 22 ++++++++++++++++------ libs/vkd3d/resource.c | 20 ++++++++++++++++++++ libs/vkd3d/vkd3d_private.h | 4 ++++ 3 files changed, 40 insertions(+), 6 deletions(-) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index b57e3ceb99e5..a3a00b92c241 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -2091,15 +2091,25 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateHeap(ID3D12Device *iface, static HRESULT STDMETHODCALLTYPE d3d12_device_CreatePlacedResource(ID3D12Device *iface, ID3D12Heap *heap, UINT64 heap_offset, const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, - const D3D12_CLEAR_VALUE *optimized_clear_value, - REFIID riid, void **resource) + const D3D12_CLEAR_VALUE *optimized_clear_value, REFIID iid, void **resource) { - FIXME("iface %p, heap %p, heap_offset %#"PRIx64", desc %p, initial_state %#x, " - "optimized_clear_value %p, riid %s, resource %p stub!\n", + struct d3d12_device *device = impl_from_ID3D12Device(iface); + struct d3d12_heap *heap_object; + struct d3d12_resource *object; + HRESULT hr; + + TRACE("iface %p, heap %p, heap_offset %#"PRIx64", desc %p, initial_state %#x, " + "optimized_clear_value %p, iid %s, resource %p.\n", iface, heap, heap_offset, desc, initial_state, - optimized_clear_value, debugstr_guid(riid), resource); + optimized_clear_value, debugstr_guid(iid), resource); - return E_NOTIMPL; + heap_object = unsafe_impl_from_ID3D12Heap(heap); + + if (FAILED(hr = d3d12_placed_resource_create(device, heap_object, heap_offset, + desc, initial_state, optimized_clear_value, &object))) + return hr; + + return return_interface(&object->ID3D12Resource_iface, &IID_ID3D12Resource, iid, resource); } static HRESULT STDMETHODCALLTYPE d3d12_device_CreateReservedResource(ID3D12Device *iface, diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index 10f1d835e792..15804500681b 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -146,6 +146,14 @@ static const struct ID3D12HeapVtbl d3d12_heap_vtbl = d3d12_heap_GetDesc, }; +struct d3d12_heap *unsafe_impl_from_ID3D12Heap(ID3D12Heap *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == &d3d12_heap_vtbl); + return impl_from_ID3D12Heap(iface); +} + static HRESULT validate_heap_desc(const D3D12_HEAP_DESC *desc) { if (!desc->SizeInBytes) @@ -1049,6 +1057,18 @@ HRESULT d3d12_committed_resource_create(struct d3d12_device *device, return S_OK; } +HRESULT d3d12_placed_resource_create(struct d3d12_device *device, struct d3d12_heap *heap, UINT64 heap_offset, + const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, + const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) +{ + const D3D12_HEAP_DESC *heap_desc = &heap->desc; + + FIXME("Ignoring heap %p, offset %"PRIu64".\n", heap, heap_offset); + + return d3d12_committed_resource_create(device, &heap_desc->Properties, heap_desc->Flags, + desc, initial_state, optimized_clear_value, resource); +} + HRESULT vkd3d_create_image_resource(ID3D12Device *device, const struct vkd3d_image_resource_create_info *create_info, ID3D12Resource **resource) { diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 5aaa56505db0..c4d6dd531728 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -195,6 +195,7 @@ struct d3d12_heap HRESULT d3d12_heap_create(struct d3d12_device *device, const D3D12_HEAP_DESC *desc, struct d3d12_heap **heap) DECLSPEC_HIDDEN; +struct d3d12_heap *unsafe_impl_from_ID3D12Heap(ID3D12Heap *iface) DECLSPEC_HIDDEN; #define VKD3D_RESOURCE_PUBLIC_FLAGS \ (VKD3D_RESOURCE_INITIAL_STATE_TRANSITION | VKD3D_RESOURCE_PRESENT_STATE_TRANSITION) @@ -245,6 +246,9 @@ HRESULT d3d12_committed_resource_create(struct d3d12_device *device, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) DECLSPEC_HIDDEN; +HRESULT d3d12_placed_resource_create(struct d3d12_device *device, struct d3d12_heap *heap, UINT64 heap_offset, + const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, + const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) DECLSPEC_HIDDEN; struct d3d12_resource *unsafe_impl_from_ID3D12Resource(ID3D12Resource *iface) DECLSPEC_HIDDEN; struct vkd3d_view -- 2.16.4

2 1

[PATCH vkd3d 3/9] vkd3d: Pass D3D12_RESOURCE_DESC and VkImage to vkd3d_create_image().
by Józef Kucia 25 Sep '18

25 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> For consistency with vkd3d_create_buffer(). Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/resource.c | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index 15804500681b..d5690deebb8e 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -321,17 +321,15 @@ static unsigned int max_miplevel_count(const D3D12_RESOURCE_DESC *desc) return vkd3d_log2i(size) + 1; } -static HRESULT vkd3d_create_image(struct d3d12_resource *resource, struct d3d12_device *device, - const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags) +static HRESULT vkd3d_create_image(struct d3d12_device *device, + const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, + const D3D12_RESOURCE_DESC *desc, VkImage *vk_image) { const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; const struct vkd3d_format *format; - const D3D12_RESOURCE_DESC *desc; VkImageCreateInfo image_info; VkResult vr; - desc = &resource->desc; - if (!(format = vkd3d_format_from_d3d12_resource_desc(desc, 0))) { WARN("Invalid DXGI format %#x.\n", desc->Format); @@ -402,7 +400,7 @@ static HRESULT vkd3d_create_image(struct d3d12_resource *resource, struct d3d12_ image_info.initialLayout = is_cpu_accessible_heap(heap_properties) ? VK_IMAGE_LAYOUT_PREINITIALIZED : VK_IMAGE_LAYOUT_UNDEFINED; - if ((vr = VK_CALL(vkCreateImage(device->vk_device, &image_info, NULL, &resource->u.vk_image))) < 0) + if ((vr = VK_CALL(vkCreateImage(device->vk_device, &image_info, NULL, vk_image))) < 0) { WARN("Failed to create Vulkan image, vr %d.\n", vr); return hresult_from_vk_result(vr); @@ -976,7 +974,8 @@ static HRESULT d3d12_resource_init(struct d3d12_resource *resource, struct d3d12 if (!resource->desc.MipLevels) resource->desc.MipLevels = max_miplevel_count(desc); resource->flags |= VKD3D_RESOURCE_INITIAL_STATE_TRANSITION; - if (FAILED(hr = vkd3d_create_image(resource, device, heap_properties, heap_flags))) + if (FAILED(hr = vkd3d_create_image(device, heap_properties, heap_flags, + &resource->desc, &resource->u.vk_image))) return hr; break; -- 2.16.4

2 1

[PATCH vkd3d 2/9] vkd3d: Implement d3d12_device_GetResourceAllocationInfo() for buffers.
by Józef Kucia 25 Sep '18

25 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> In Direct3D12, D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT is always used for buffers. We could try to use a lower alignment when supported by the Vulkan implementation, but there is no way to get buffer memory requirements without creating a buffer in Vulkan. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/device.c | 39 +++++++++++++++++++++++++++++++++------ 1 file changed, 33 insertions(+), 6 deletions(-) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index a3a00b92c241..54196acb83e8 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -2022,16 +2022,43 @@ static void STDMETHODCALLTYPE d3d12_device_CopyDescriptorsSimple(ID3D12Device *i } static D3D12_RESOURCE_ALLOCATION_INFO * STDMETHODCALLTYPE d3d12_device_GetResourceAllocationInfo( - ID3D12Device *iface, D3D12_RESOURCE_ALLOCATION_INFO *allocation_info, UINT visible_mask, - UINT resource_desc_count, const D3D12_RESOURCE_DESC *resource_descs) + ID3D12Device *iface, D3D12_RESOURCE_ALLOCATION_INFO *info, UINT visible_mask, + UINT count, const D3D12_RESOURCE_DESC *resource_descs) { - FIXME("iface %p, allocation_info %p, visible_mask 0x%08x, resource_desc_count %u, " - "resource_descs %p stub!\n", - iface, allocation_info, visible_mask, resource_desc_count, resource_descs); + const D3D12_RESOURCE_DESC *desc; + + TRACE("iface %p, info %p, visible_mask 0x%08x, count %u, resource_descs %p.\n", + iface, info, visible_mask, count, resource_descs); debug_ignored_node_mask(visible_mask); - return allocation_info; + info->SizeInBytes = 0; + info->Alignment = 0; + + if (count != 1) + { + FIXME("Multiple resource descriptions not supported.\n"); + return info; + } + + desc = &resource_descs[0]; + if (desc->Dimension == D3D12_RESOURCE_DIMENSION_BUFFER) + { + info->SizeInBytes = align(desc->Width, D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT); + info->Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT; + } + else + { + FIXME("Unhandled dimension %#x.\n", desc->Dimension); + } + + if (FAILED(d3d12_resource_validate_desc(desc))) + { + WARN("Invalid resource desc.\n"); + info->SizeInBytes = ~(UINT64)0; + } + + return info; } static D3D12_HEAP_PROPERTIES * STDMETHODCALLTYPE d3d12_device_GetCustomHeapProperties(ID3D12Device *iface, -- 2.16.4

2 1

[PATCH] d2d1: Add ID2D1Effect stub.
by Nikolay Sivov 25 Sep '18

25 Sep '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/d2d1/Makefile.in | 1 + dlls/d2d1/d2d1_private.h | 8 ++ dlls/d2d1/device.c | 12 ++- dlls/d2d1/effect.c | 215 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 235 insertions(+), 1 deletion(-) create mode 100644 dlls/d2d1/effect.c diff --git a/dlls/d2d1/Makefile.in b/dlls/d2d1/Makefile.in index 4bfe3b5953..413571338b 100644 --- a/dlls/d2d1/Makefile.in +++ b/dlls/d2d1/Makefile.in @@ -9,6 +9,7 @@ C_SRCS = \ brush.c \ dc_render_target.c \ device.c \ + effect.c \ factory.c \ geometry.c \ hwnd_render_target.c \ diff --git a/dlls/d2d1/d2d1_private.h b/dlls/d2d1/d2d1_private.h index 2d3acd5997..f378722b5d 100644 --- a/dlls/d2d1/d2d1_private.h +++ b/dlls/d2d1/d2d1_private.h @@ -503,6 +503,14 @@ struct d2d_device void d2d_device_init(struct d2d_device *device, ID2D1Factory1 *factory, IDXGIDevice *dxgi_device) DECLSPEC_HIDDEN; +struct d2d_effect +{ + ID2D1Effect ID2D1Effect_iface; + LONG refcount; +}; + +void d2d_effect_init(struct d2d_effect *effect) DECLSPEC_HIDDEN; + static inline BOOL d2d_array_reserve(void **elements, size_t *capacity, size_t count, size_t size) { size_t new_capacity, max_capacity; diff --git a/dlls/d2d1/device.c b/dlls/d2d1/device.c index be8b7eab03..e2fa414c58 100644 --- a/dlls/d2d1/device.c +++ b/dlls/d2d1/device.c @@ -1858,9 +1858,19 @@ static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateBitmapFromDxgiSurface( static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateEffect(ID2D1DeviceContext *iface, REFCLSID effect_id, ID2D1Effect **effect) { + struct d2d_effect *object; + FIXME("iface %p, effect_id %s, effect %p stub!\n", iface, debugstr_guid(effect_id), effect); - return E_NOTIMPL; + if (!(object = heap_alloc_zero(sizeof(*object)))) + return E_OUTOFMEMORY; + + d2d_effect_init(object); + + TRACE("Created effect %p.\n", object); + *effect = &object->ID2D1Effect_iface; + + return S_OK; } static HRESULT STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_CreateGradientStopCollection( diff --git a/dlls/d2d1/effect.c b/dlls/d2d1/effect.c new file mode 100644 index 0000000000..b13269330f --- /dev/null +++ b/dlls/d2d1/effect.c @@ -0,0 +1,215 @@ +/* + * Copyright 2018 Nikolay Sivov for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "config.h" +#include "wine/port.h" + +#include "d2d1_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d2d); + +static inline struct d2d_effect *impl_from_ID2D1Effect(ID2D1Effect *iface) +{ + return CONTAINING_RECORD(iface, struct d2d_effect, ID2D1Effect_iface); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_QueryInterface(ID2D1Effect *iface, REFIID iid, void **out) +{ + TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); + + if (IsEqualGUID(iid, &IID_ID2D1Effect) + || IsEqualGUID(iid, &IID_ID2D1Properties) + || IsEqualGUID(iid, &IID_IUnknown)) + { + ID2D1Effect_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG STDMETHODCALLTYPE d2d_effect_AddRef(ID2D1Effect *iface) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + ULONG refcount = InterlockedIncrement(&effect->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, refcount); + + return refcount; +} + +static ULONG STDMETHODCALLTYPE d2d_effect_Release(ID2D1Effect *iface) +{ + struct d2d_effect *effect = impl_from_ID2D1Effect(iface); + ULONG refcount = InterlockedDecrement(&effect->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, refcount); + + if (!refcount) + heap_free(effect); + + return refcount; +} + +static UINT32 STDMETHODCALLTYPE d2d_effect_GetPropertyCount(ID2D1Effect *iface) +{ + FIXME("iface %p stub!\n", iface); + + return 0; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_GetPropertyName(ID2D1Effect *iface, UINT32 index, + WCHAR *name, UINT32 name_count) +{ + FIXME("iface %p, index %u, name %s, name_count %u stub!\n", iface, index, debugstr_wn(name, name_count), name_count); + + return E_NOTIMPL; +} + +static UINT32 STDMETHODCALLTYPE d2d_effect_GetPropertyNameLength(ID2D1Effect *iface, UINT32 index) +{ + FIXME("iface %p, index %u stub!\n", iface, index); + + return 0; +} + +static D2D1_PROPERTY_TYPE STDMETHODCALLTYPE d2d_effect_GetType(ID2D1Effect *iface, UINT32 index) +{ + FIXME("iface %p, index %u stub!\n", iface, index); + + return 0; +} + +static UINT32 STDMETHODCALLTYPE d2d_effect_GetPropertyIndex(ID2D1Effect *iface, const WCHAR *name) +{ + FIXME("iface %p, name %s stub!\n", iface, debugstr_w(name)); + + return 0; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_SetValueByName(ID2D1Effect *iface, const WCHAR *name, + D2D1_PROPERTY_TYPE type, const BYTE *value, UINT32 value_size) +{ + FIXME("iface %p, name %s, type %#x, value %p, value_size %u stub!\n", iface, debugstr_w(name), + type, value, value_size); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_SetValue(ID2D1Effect *iface, UINT32 index, D2D1_PROPERTY_TYPE type, + const BYTE *value, UINT32 value_size) +{ + FIXME("iface %p, index %u, type %#x, value %p, value_size %u stub!\n", iface, index, type, value, value_size); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_GetValueByName(ID2D1Effect *iface, const WCHAR *name, + D2D1_PROPERTY_TYPE type, BYTE *value, UINT32 value_size) +{ + FIXME("iface %p, name %s, type %#x, value %p, value_size %u stub!\n", iface, debugstr_w(name), type, + value, value_size); + + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_GetValue(ID2D1Effect *iface, UINT32 index, D2D1_PROPERTY_TYPE type, + BYTE *value, UINT32 value_size) +{ + FIXME("iface %p, index %u, type %#x, value %p, value_size %u stub!\n", iface, index, type, + value, value_size); + + return E_NOTIMPL; +} + +static UINT32 STDMETHODCALLTYPE d2d_effect_GetValueSize(ID2D1Effect *iface, UINT32 index) +{ + FIXME("iface %p, index %u stub!\n", iface, index); + + return 0; +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_GetSubProperties(ID2D1Effect *iface, UINT32 index, ID2D1Properties **props) +{ + FIXME("iface %p, index %u, props %p stub!\n", iface, index, props); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE d2d_effect_SetInput(ID2D1Effect *iface, UINT32 index, ID2D1Image *input, BOOL invalidate) +{ + FIXME("iface %p, index %u, input %p, invalidate %d stub!\n", iface, index, input, invalidate); +} + +static HRESULT STDMETHODCALLTYPE d2d_effect_SetInputCount(ID2D1Effect *iface, UINT32 count) +{ + FIXME("iface %p, count %u stub!\n", iface, count); + + return E_NOTIMPL; +} + +static void STDMETHODCALLTYPE d2d_effect_GetInput(ID2D1Effect *iface, UINT32 index, ID2D1Image **input) +{ + FIXME("iface %p, index %u, input %p stub!\n", iface, index, input); +} + +static UINT32 STDMETHODCALLTYPE d2d_effect_GetInputCount(ID2D1Effect *iface) +{ + FIXME("iface %p stub!\n", iface); + + return 0; +} + +static void STDMETHODCALLTYPE d2d_effect_GetOutput(ID2D1Effect *iface, ID2D1Image **output) +{ + FIXME("iface %p, output %p stub!\n", iface, output); +} + +static const ID2D1EffectVtbl d2d_effect_vtbl = +{ + d2d_effect_QueryInterface, + d2d_effect_AddRef, + d2d_effect_Release, + d2d_effect_GetPropertyCount, + d2d_effect_GetPropertyName, + d2d_effect_GetPropertyNameLength, + d2d_effect_GetType, + d2d_effect_GetPropertyIndex, + d2d_effect_SetValueByName, + d2d_effect_SetValue, + d2d_effect_GetValueByName, + d2d_effect_GetValue, + d2d_effect_GetValueSize, + d2d_effect_GetSubProperties, + d2d_effect_SetInput, + d2d_effect_SetInputCount, + d2d_effect_GetInput, + d2d_effect_GetInputCount, + d2d_effect_GetOutput, +}; + +void d2d_effect_init(struct d2d_effect *effect) +{ + effect->ID2D1Effect_iface.lpVtbl = &d2d_effect_vtbl; + effect->refcount = 1; +} + -- 2.19.0

2 1

[PATCH resend v2 1/4] comctl32/edit: Get rid of useless float cast
by Gabriel Ivăncescu 25 Sep '18

25 Sep '18

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- v2: Use a signed variable to get rid of some casts. dlls/comctl32/edit.c | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/dlls/comctl32/edit.c b/dlls/comctl32/edit.c index f0180ad..3f2e48c 100644 --- a/dlls/comctl32/edit.c +++ b/dlls/comctl32/edit.c @@ -4906,9 +4906,10 @@ static LRESULT CALLBACK EDIT_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPAR case WM_MOUSEWHEEL: { - int wheelDelta; - UINT pulScrollLines = 3; - SystemParametersInfoW(SPI_GETWHEELSCROLLLINES,0, &pulScrollLines, 0); + INT wheelDelta, pulScrollLines; + UINT tmp = 3; + SystemParametersInfoW(SPI_GETWHEELSCROLLLINES,0, &tmp, 0); + pulScrollLines = tmp; if (wParam & (MK_SHIFT | MK_CONTROL)) { @@ -4926,10 +4927,10 @@ static LRESULT CALLBACK EDIT_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPAR if (es->wheelDeltaRemainder && pulScrollLines) { - int cLineScroll; - pulScrollLines = (int) min((UINT) es->line_count, pulScrollLines); - cLineScroll = pulScrollLines * (float)es->wheelDeltaRemainder / WHEEL_DELTA; - es->wheelDeltaRemainder -= WHEEL_DELTA * cLineScroll / (int)pulScrollLines; + INT cLineScroll; + pulScrollLines = min((UINT)es->line_count, pulScrollLines); + cLineScroll = (pulScrollLines * es->wheelDeltaRemainder) / WHEEL_DELTA; + es->wheelDeltaRemainder -= (cLineScroll * WHEEL_DELTA) / pulScrollLines; result = EDIT_EM_LineScroll(es, 0, -cLineScroll); } break; -- 1.9.1

1 3

[PATCH resend v2 1/2] comctl32/listbox: Handle Mouse Wheel scrolling for multi-column listboxes properly
by Gabriel Ivăncescu 25 Sep '18

25 Sep '18

Multi-column listboxes scroll horizontally, so each wheel tick must go an entire page at a time instead of an item at a time. But we have to limit the amount of scrolling in this case to avoid "jumping over" columns, if the window is too small. This matches Windows behavior. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=22253 Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- v2: Use a signed variable to get rid of some casts. The calculation has also been simplified to just integer arithmetic in all cases, since the division (the only operation with a fractional result) was immediately truncated to integer anyway, so the float cast was useless. This works fine because the multiplication is done before the division (parentheses have been added to emphasize this point). dlls/comctl32/listbox.c | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-) diff --git a/dlls/comctl32/listbox.c b/dlls/comctl32/listbox.c index 2137ef8..7aa273a 100644 --- a/dlls/comctl32/listbox.c +++ b/dlls/comctl32/listbox.c @@ -1995,9 +1995,11 @@ static LRESULT LISTBOX_HandleHScroll( LB_DESCR *descr, WORD scrollReq, WORD pos static LRESULT LISTBOX_HandleMouseWheel(LB_DESCR *descr, SHORT delta ) { - UINT pulScrollLines = 3; + INT pulScrollLines; + UINT tmp = 3; - SystemParametersInfoW(SPI_GETWHEELSCROLLLINES,0, &pulScrollLines, 0); + SystemParametersInfoW(SPI_GETWHEELSCROLLLINES,0, &tmp, 0); + pulScrollLines = tmp; /* if scrolling changes direction, ignore left overs */ if ((delta < 0 && descr->wheel_remain < 0) || @@ -2008,10 +2010,21 @@ static LRESULT LISTBOX_HandleMouseWheel(LB_DESCR *descr, SHORT delta ) if (descr->wheel_remain && pulScrollLines) { - int cLineScroll; - pulScrollLines = min((UINT) descr->page_size, pulScrollLines); - cLineScroll = pulScrollLines * (float)descr->wheel_remain / WHEEL_DELTA; - descr->wheel_remain -= WHEEL_DELTA * cLineScroll / (int)pulScrollLines; + INT cLineScroll; + if (descr->style & LBS_MULTICOLUMN) + { + pulScrollLines = min((UINT)descr->width / descr->column_width, pulScrollLines); + pulScrollLines = max(1U, pulScrollLines); + cLineScroll = (pulScrollLines * descr->wheel_remain) / WHEEL_DELTA; + descr->wheel_remain -= (cLineScroll * WHEEL_DELTA) / pulScrollLines; + cLineScroll *= descr->page_size; + } + else + { + pulScrollLines = min((UINT)descr->page_size, pulScrollLines); + cLineScroll = (pulScrollLines * descr->wheel_remain) / WHEEL_DELTA; + descr->wheel_remain -= (cLineScroll * WHEEL_DELTA) / pulScrollLines; + } LISTBOX_SetTopItem( descr, descr->top_item - cLineScroll, TRUE ); } return 0; -- 1.9.1

1 1

[PATCH] testbot: Better check for the "No build or test VM" disposition.
by Francois Gouget 25 Sep '18

25 Sep '18

Use a direct test instead of an indirect one. Also the $Impacts->{UnitCount} field has been renamed. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- testbot/lib/WineTestBot/Patches.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testbot/lib/WineTestBot/Patches.pm b/testbot/lib/WineTestBot/Patches.pm index 469fedcdc..96e4a0dda 100644 --- a/testbot/lib/WineTestBot/Patches.pm +++ b/testbot/lib/WineTestBot/Patches.pm @@ -266,7 +266,7 @@ sub Submit($$$) if ($NewJob->Steps->IsEmpty()) { # This may be a Wine patch but there is no suitable VM to test it! - if ($Impacts->{UnitCount}) + if ($BuildVMs->IsEmpty() and $WineVMs->IsEmpty()) { $self->Disposition("No build or test VM!"); } -- 2.19.0

1 0

[PATCH] testbot/web: Avoid race conditions when submitting jobs.
by Francois Gouget 25 Sep '18

25 Sep '18

Rename the patch so one instance of Submit.pl gets exclusive access to it and only one job gets created. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- testbot/web/Submit.pl | 52 ++++++++++++++++++++++++++++++++----------- 1 file changed, 39 insertions(+), 13 deletions(-) diff --git a/testbot/web/Submit.pl b/testbot/web/Submit.pl index ae4aca3dd..9ad8fd5e0 100644 --- a/testbot/web/Submit.pl +++ b/testbot/web/Submit.pl @@ -745,13 +745,9 @@ sub OnPrev($) return $self->{Page} == 3 ? $self->OnPage3Prev() : $self->OnPage2Prev(); } -sub OnSubmit($) +sub SubmitJob($$$) { - my ($self) = @_; - - return !1 if (!$self->Validate()); - my $BaseName = $self->ValidateAndGetFileName("FileName"); - return !1 if (!$BaseName); + my ($self, $BaseName, $Staging) = @_; # See also Patches::Submit() in lib/WineTestBot/Patches.pm @@ -778,11 +774,7 @@ sub OnSubmit($) # Add steps and tasks for the 32 and 64-bit tests my $FileType = $self->GetParam("FileType"); my $Impacts; - if ($FileType eq "patch") - { - my $TmpStagingFullPath = $self->GetTmpStagingFullPath($BaseName); - $Impacts = GetPatchImpacts($TmpStagingFullPath); - } + $Impacts = GetPatchImpacts($Staging) if ($FileType eq "patch"); my $BuildStep; foreach my $Bits ("32", "64") @@ -913,8 +905,7 @@ sub OnSubmit($) } # Stage the test patch/executable so the job can pick it up - my $TmpStagingFullPath = $self->GetTmpStagingFullPath($BaseName); - if (!rename($TmpStagingFullPath, "$DataDir/staging/job". $NewJob->Id ."_$BaseName")) + if (!rename($Staging, "$DataDir/staging/job". $NewJob->Id ."_$BaseName")) { $self->{ErrMessage} = "Could not stage '$BaseName': $!\n"; return !1; @@ -943,6 +934,41 @@ sub OnSubmit($) exit; } +sub OnSubmit($) +{ + my ($self) = @_; + + return !1 if (!$self->Validate()); + my $BaseName = $self->ValidateAndGetFileName("FileName"); + return !1 if (!$BaseName); + + # Rename the staging file to avoid race conditions if the user clicks on + # Submit multiple times + my $OldStaging = $self->GetTmpStagingFullPath($BaseName); + my $Staging = CreateNewLink($OldStaging, "$DataDir/staging", $BaseName); + if (!defined $Staging) + { + $self->{ErrMessage} = "Could not rename '$BaseName': $!"; + return !1; + } + if (!unlink $OldStaging) + { + unlink $Staging; + $self->{ErrMessage} = $!{ENOENT} ? + "$BaseName has already been submitted or has expired" : + "Could not remove the staging '$BaseName' file: $!"; + return !1; + } + + if (!$self->SubmitJob($BaseName, $Staging)) + { + # Restore the file for the next attempt + rename($Staging, $OldStaging); + return !1; + } + return 1; +} + sub OnShowAllVMs($) { my ($self) = @_; -- 2.19.0

1 0

[PATCH] testbot: Retry updating the wine / build VMs after a timeout.
by Francois Gouget 25 Sep '18

25 Sep '18

In case of a regular build failure, retrying is pointless. But in case of a timeout the VM host may be less busy next time and since the snapshot is unchanged we can retry. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- testbot/bin/WineRunReconfig.pl | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/testbot/bin/WineRunReconfig.pl b/testbot/bin/WineRunReconfig.pl index 19f5ed467..6dd131826 100755 --- a/testbot/bin/WineRunReconfig.pl +++ b/testbot/bin/WineRunReconfig.pl @@ -481,4 +481,7 @@ if ($NewStatus eq 'completed') # Wrap up # -WrapUpAndExit($NewStatus, undef, $TaskTimedOut); +# In case of a regular build failure retrying is pointless. But in case of a +# timeout the VM host may be less busy next time and since the snapshot is +# unchanged we can retry. +WrapUpAndExit($NewStatus, $TaskTimedOut, $TaskTimedOut); -- 2.19.0

1 0

[PATCH] crypt32/base64: Fix certificate request header and trailer in CryptBinaryToStringW() output.
by Nikolay Sivov 25 Sep '18

25 Sep '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/crypt32/base64.c | 4 +- dlls/crypt32/tests/base64.c | 226 +++++++++++++++++++++++++----------- 2 files changed, 159 insertions(+), 71 deletions(-) diff --git a/dlls/crypt32/base64.c b/dlls/crypt32/base64.c index 2ba8055961..bc30779098 100644 --- a/dlls/crypt32/base64.c +++ b/dlls/crypt32/base64.c @@ -53,10 +53,10 @@ static const WCHAR CERT_TRAILER_START_W[] = { '-','-','-','-','-','E','N','D',' ',0 }; static const WCHAR CERT_REQUEST_HEADER_W[] = { '-','-','-','-','-','B','E','G','I','N',' ','N','E','W',' ','C','E','R','T', -'I','F','I','C','A','T','E','R','E','Q','U','E','S','T','-','-','-','-','-',0 }; +'I','F','I','C','A','T','E',' ','R','E','Q','U','E','S','T','-','-','-','-','-',0 }; static const WCHAR CERT_REQUEST_TRAILER_W[] = { '-','-','-','-','-','E','N','D',' ','N','E','W',' ','C','E','R','T','I','F', -'I','C','A','T','E','R','E','Q','U','E','S','T','-','-','-','-','-',0 }; +'I','C','A','T','E',' ','R','E','Q','U','E','S','T','-','-','-','-','-',0 }; static const WCHAR X509_HEADER_W[] = { '-','-','-','-','-','B','E','G','I','N',' ','X','5','0','9',' ','C','R','L', '-','-','-','-','-',0 }; diff --git a/dlls/crypt32/tests/base64.c b/dlls/crypt32/tests/base64.c index 633e6d1775..7bc1ec7d0e 100644 --- a/dlls/crypt32/tests/base64.c +++ b/dlls/crypt32/tests/base64.c @@ -20,11 +20,10 @@ */ #include <stdio.h> #include <stdarg.h> -#include <windef.h> -#include <winbase.h> -#include <winerror.h> +#include <windows.h> #include <wincrypt.h> +#include "wine/heap.h" #include "wine/test.h" #define CERT_HEADER "-----BEGIN CERTIFICATE-----\r\n" @@ -81,6 +80,19 @@ static const struct BinTests testsNoCR[] = { "SElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NTY3ODkwAA==\n" }, }; +static WCHAR *strdupAtoW(const char *str) +{ + WCHAR *ret = NULL; + DWORD len; + + if (!str) return ret; + len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0); + ret = heap_alloc(len * sizeof(WCHAR)); + if (ret) + MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len); + return ret; +} + static void encodeAndCompareBase64_A(const BYTE *toEncode, DWORD toEncodeLen, DWORD format, const char *expected, const char *header, const char *trailer) { @@ -117,93 +129,169 @@ static void encodeAndCompareBase64_A(const BYTE *toEncode, DWORD toEncodeLen, } } -static void testBinaryToStringA(void) +static void encode_compare_base64_W(const BYTE *toEncode, DWORD toEncodeLen, DWORD format, + const WCHAR *expected, const char *header, const char *trailer) +{ + WCHAR *headerW, *trailerW; + DWORD strLen = 0, strLen2; + const WCHAR *ptr; + WCHAR *strW; + BOOL ret; + + ret = CryptBinaryToStringW(toEncode, toEncodeLen, format, NULL, &strLen); + ok(ret, "CryptBinaryToStringW failed: %d\n", GetLastError()); + + strLen2 = strLen; + strW = heap_alloc(strLen * sizeof(WCHAR)); + ret = CryptBinaryToStringW(toEncode, toEncodeLen, format, strW, &strLen2); + ok(ret, "CryptBinaryToStringW failed: %d\n", GetLastError()); + ok(strLen2 == strLen - 1, "Expected length %d, got %d\n", strLen - 1, strLen); + + headerW = strdupAtoW(header); + trailerW = strdupAtoW(trailer); + + ptr = strW; + if (headerW) + { + ok(!memcmp(headerW, ptr, lstrlenW(headerW)), "Expected header %s, got %s.\n", wine_dbgstr_w(headerW), + wine_dbgstr_w(ptr)); + ptr += lstrlenW(headerW); + } + ok(!memcmp(expected, ptr, lstrlenW(expected)), "Expected %s, got %s.\n", wine_dbgstr_w(expected), + wine_dbgstr_w(ptr)); + ptr += lstrlenW(expected); + if (trailerW) + ok(!memcmp(trailerW, ptr, lstrlenW(trailerW)), "Expected trailer %s, got %s.\n", wine_dbgstr_w(trailerW), + wine_dbgstr_w(ptr)); + + heap_free(strW); + heap_free(headerW); + heap_free(trailerW); +} + +static void test_CryptBinaryToString(void) { + DWORD strLen, strLen2, i; BOOL ret; - DWORD strLen = 0, i; ret = CryptBinaryToStringA(NULL, 0, 0, NULL, NULL); ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError()); + + strLen = 123; ret = CryptBinaryToStringA(NULL, 0, 0, NULL, &strLen); ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError()); + ok(strLen == 123, "Unexpected length.\n"); + + if (0) + ret = CryptBinaryToStringW(NULL, 0, 0, NULL, NULL); + + strLen = 123; + ret = CryptBinaryToStringW(NULL, 0, 0, NULL, &strLen); + ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "Unexpected error %d\n", GetLastError()); + ok(strLen == 123, "Unexpected length.\n"); + for (i = 0; i < ARRAY_SIZE(tests); i++) { - DWORD strLen = 0; + WCHAR *strW, *encodedW; LPSTR str = NULL; BOOL ret; - ret = CryptBinaryToStringA(tests[i].toEncode, tests[i].toEncodeLen, - CRYPT_STRING_BINARY, NULL, &strLen); + strLen = 0; + ret = CryptBinaryToStringA(tests[i].toEncode, tests[i].toEncodeLen, CRYPT_STRING_BINARY, NULL, &strLen); ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError()); - str = HeapAlloc(GetProcessHeap(), 0, strLen); - if (str) - { - DWORD strLen2 = strLen; - - ret = CryptBinaryToStringA(tests[i].toEncode, tests[i].toEncodeLen, - CRYPT_STRING_BINARY, str, &strLen2); - ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError()); - ok(strLen == strLen2, "Expected length %d, got %d\n", strLen, - strLen2); - ok(!memcmp(str, tests[i].toEncode, tests[i].toEncodeLen), - "Unexpected value\n"); - HeapFree(GetProcessHeap(), 0, str); - } - encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen, - CRYPT_STRING_BASE64, tests[i].base64, NULL, NULL); - encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen, - CRYPT_STRING_BASE64HEADER, tests[i].base64, CERT_HEADER, - CERT_TRAILER); - encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen, - CRYPT_STRING_BASE64REQUESTHEADER, tests[i].base64, - CERT_REQUEST_HEADER, CERT_REQUEST_TRAILER); - encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen, - CRYPT_STRING_BASE64X509CRLHEADER, tests[i].base64, X509_HEADER, - X509_TRAILER); + ok(strLen == tests[i].toEncodeLen, "Unexpected required length %u.\n", strLen); + + strLen2 = strLen; + str = heap_alloc(strLen); + ret = CryptBinaryToStringA(tests[i].toEncode, tests[i].toEncodeLen, CRYPT_STRING_BINARY, str, &strLen2); + ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError()); + ok(strLen == strLen2, "Expected length %u, got %u\n", strLen, strLen2); + ok(!memcmp(str, tests[i].toEncode, tests[i].toEncodeLen), "Unexpected value\n"); + heap_free(str); + + strLen = 0; + ret = CryptBinaryToStringW(tests[i].toEncode, tests[i].toEncodeLen, CRYPT_STRING_BINARY, NULL, &strLen); + todo_wine { + ok(ret, "CryptBinaryToStringW failed: %d\n", GetLastError()); + ok(strLen == tests[i].toEncodeLen, "Unexpected required length %u.\n", strLen); } + strLen2 = strLen; + strW = heap_alloc(strLen); + ret = CryptBinaryToStringW(tests[i].toEncode, tests[i].toEncodeLen, CRYPT_STRING_BINARY, strW, &strLen2); + todo_wine + ok(ret, "CryptBinaryToStringW failed: %d\n", GetLastError()); + ok(strLen == strLen2, "Expected length %u, got %u\n", strLen, strLen2); + todo_wine + ok(!memcmp(strW, tests[i].toEncode, tests[i].toEncodeLen), "Unexpected value\n"); + heap_free(strW); + + encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen, CRYPT_STRING_BASE64, + tests[i].base64, NULL, NULL); + encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen, CRYPT_STRING_BASE64HEADER, + tests[i].base64, CERT_HEADER, CERT_TRAILER); + encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen, CRYPT_STRING_BASE64REQUESTHEADER, + tests[i].base64, CERT_REQUEST_HEADER, CERT_REQUEST_TRAILER); + encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen, CRYPT_STRING_BASE64X509CRLHEADER, + tests[i].base64, X509_HEADER, X509_TRAILER); + + encodedW = strdupAtoW(tests[i].base64); + + encode_compare_base64_W(tests[i].toEncode, tests[i].toEncodeLen, CRYPT_STRING_BASE64, encodedW, NULL, NULL); + encode_compare_base64_W(tests[i].toEncode, tests[i].toEncodeLen, CRYPT_STRING_BASE64HEADER, encodedW, + CERT_HEADER, CERT_TRAILER); + encode_compare_base64_W(tests[i].toEncode, tests[i].toEncodeLen, CRYPT_STRING_BASE64REQUESTHEADER, + encodedW, CERT_REQUEST_HEADER, CERT_REQUEST_TRAILER); + encode_compare_base64_W(tests[i].toEncode, tests[i].toEncodeLen, CRYPT_STRING_BASE64X509CRLHEADER, encodedW, + X509_HEADER, X509_TRAILER); + + heap_free(encodedW); + } + for (i = 0; i < ARRAY_SIZE(testsNoCR); i++) { - DWORD strLen = 0; LPSTR str = NULL; + WCHAR *encodedW; BOOL ret; - ret = CryptBinaryToStringA(testsNoCR[i].toEncode, - testsNoCR[i].toEncodeLen, CRYPT_STRING_BINARY | CRYPT_STRING_NOCR, - NULL, &strLen); + ret = CryptBinaryToStringA(testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen, + CRYPT_STRING_BINARY | CRYPT_STRING_NOCR, NULL, &strLen); ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError()); - str = HeapAlloc(GetProcessHeap(), 0, strLen); - if (str) - { - DWORD strLen2 = strLen; - - ret = CryptBinaryToStringA(testsNoCR[i].toEncode, - testsNoCR[i].toEncodeLen, CRYPT_STRING_BINARY | CRYPT_STRING_NOCR, - str, &strLen2); - ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError()); - ok(strLen == strLen2, "Expected length %d, got %d\n", strLen, - strLen2); - ok(!memcmp(str, testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen), - "Unexpected value\n"); - HeapFree(GetProcessHeap(), 0, str); - } - encodeAndCompareBase64_A(testsNoCR[i].toEncode, - testsNoCR[i].toEncodeLen, CRYPT_STRING_BASE64 | CRYPT_STRING_NOCR, - testsNoCR[i].base64, NULL, NULL); - encodeAndCompareBase64_A(testsNoCR[i].toEncode, - testsNoCR[i].toEncodeLen, - CRYPT_STRING_BASE64HEADER | CRYPT_STRING_NOCR, testsNoCR[i].base64, - CERT_HEADER_NOCR, CERT_TRAILER_NOCR); - encodeAndCompareBase64_A(testsNoCR[i].toEncode, - testsNoCR[i].toEncodeLen, - CRYPT_STRING_BASE64REQUESTHEADER | CRYPT_STRING_NOCR, - testsNoCR[i].base64, CERT_REQUEST_HEADER_NOCR, - CERT_REQUEST_TRAILER_NOCR); - encodeAndCompareBase64_A(testsNoCR[i].toEncode, - testsNoCR[i].toEncodeLen, - CRYPT_STRING_BASE64X509CRLHEADER | CRYPT_STRING_NOCR, - testsNoCR[i].base64, X509_HEADER_NOCR, X509_TRAILER_NOCR); + + strLen2 = strLen; + str = heap_alloc(strLen); + ret = CryptBinaryToStringA(testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen, + CRYPT_STRING_BINARY | CRYPT_STRING_NOCR, str, &strLen2); + ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError()); + ok(strLen == strLen2, "Expected length %d, got %d\n", strLen, strLen2); + ok(!memcmp(str, testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen), "Unexpected value\n"); + heap_free(str); + + encodeAndCompareBase64_A(testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen, CRYPT_STRING_BASE64 | CRYPT_STRING_NOCR, + testsNoCR[i].base64, NULL, NULL); + encodeAndCompareBase64_A(testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen, + CRYPT_STRING_BASE64HEADER | CRYPT_STRING_NOCR, testsNoCR[i].base64, CERT_HEADER_NOCR, CERT_TRAILER_NOCR); + encodeAndCompareBase64_A(testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen, + CRYPT_STRING_BASE64REQUESTHEADER | CRYPT_STRING_NOCR, testsNoCR[i].base64, CERT_REQUEST_HEADER_NOCR, + CERT_REQUEST_TRAILER_NOCR); + encodeAndCompareBase64_A(testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen, + CRYPT_STRING_BASE64X509CRLHEADER | CRYPT_STRING_NOCR, testsNoCR[i].base64, X509_HEADER_NOCR, X509_TRAILER_NOCR); + + encodedW = strdupAtoW(testsNoCR[i].base64); + + encode_compare_base64_W(testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen, + CRYPT_STRING_BASE64 | CRYPT_STRING_NOCR, encodedW, NULL, NULL); + encode_compare_base64_W(testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen, + CRYPT_STRING_BASE64HEADER | CRYPT_STRING_NOCR, encodedW, CERT_HEADER_NOCR, CERT_TRAILER_NOCR); + encode_compare_base64_W(testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen, + CRYPT_STRING_BASE64REQUESTHEADER | CRYPT_STRING_NOCR, encodedW, CERT_REQUEST_HEADER_NOCR, + CERT_REQUEST_TRAILER_NOCR); + encode_compare_base64_W(testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen, + CRYPT_STRING_BASE64X509CRLHEADER | CRYPT_STRING_NOCR, encodedW, + X509_HEADER_NOCR, X509_TRAILER_NOCR); + + heap_free(encodedW); } } @@ -545,6 +633,6 @@ static void testStringToBinaryA(void) START_TEST(base64) { - testBinaryToStringA(); + test_CryptBinaryToString(); testStringToBinaryA(); } -- 2.19.0

1 0

[PATCH] quartz: Don't round a <1sec difference to 0 in WAVEParserImpl_seek
by Alex Henrie 25 Sep '18

25 Sep '18

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=34302 Signed-off-by: Alex Henrie <alexhenrie24(a)gmail.com> --- For some reason, the game sets the audio stream position to a negative value, then seeks to 0. If Wine decides that it doesn't actually need to do the seek operation, it then reads garbage data from the negative offset. Unfortunately, there is still another bug with the audio in this game: Wine keeps reading past the end of the audio stream, causing a crash at the end of the audio clip. --- dlls/quartz/waveparser.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/dlls/quartz/waveparser.c b/dlls/quartz/waveparser.c index fa9cd45d27..995e43196d 100644 --- a/dlls/quartz/waveparser.c +++ b/dlls/quartz/waveparser.c @@ -211,10 +211,9 @@ static HRESULT WINAPI WAVEParserImpl_seek(IMediaSeeking *iface) return E_INVALIDARG; } - if (curpos/1000000 == newpos/1000000) + if (curpos == newpos) { - TRACE("Requesting position %s same as current position %s\n", - wine_dbgstr_longlong(newpos), wine_dbgstr_longlong(curpos)); + TRACE("Requesting position %s same as current position\n", wine_dbgstr_longlong(newpos)); return S_OK; } -- 2.19.0

2 1

[PATCH 1/4] msvcrt: Do not put cmd.exe special environment variables into the environ
by Jason Edmeades 25 Sep '18

25 Sep '18

All the special environment variables from the command shell which track directory use are stripped out from the C runtime environ/wenviron. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=45320 --- Note this cannot be tested by the test suites because it only gets triggered for C applications launched from the command shell - if you launch them from explorer on windows for example, they are not set either. I've attached a comprehensive set of tests onto the bug as an attachment, which tests the interaction of these special variables, the current directory and the C runtime vs the command shell. The way I have chosen to implement this leaves the special variables content in the allocated memory, allowing the memcpy of the environment strings, but does not put a pointer to that data in the char** array of strings. An alternative implementation would copy in string by string and skip them, but I have chosen to leave that unless something is broken because of it. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=45320 Signed-off-by: Jason Edmeades <us(a)edmeades.me.uk> --- dlls/msvcrt/data.c | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/dlls/msvcrt/data.c b/dlls/msvcrt/data.c index 06e16a865e..f08d9b1683 100644 --- a/dlls/msvcrt/data.c +++ b/dlls/msvcrt/data.c @@ -73,7 +73,8 @@ char ** msvcrt_SnapshotOfEnvironmentA(char **blk) for (ptr = environ_strings; *ptr; ptr += strlen(ptr) + 1) { - count++; + /* Don't count environment variables starting with '=' which are command shell specific */ + if (*ptr != '=') count++; len += strlen(ptr) + 1; } if (blk) @@ -88,7 +89,8 @@ char ** msvcrt_SnapshotOfEnvironmentA(char **blk) memcpy(&blk[count],environ_strings,len); for (ptr = (char*) &blk[count]; *ptr; ptr += strlen(ptr) + 1) { - blk[i++] = ptr; + /* Skip special environment strings set by the command shell */ + if (*ptr != '=') blk[i++] = ptr; } } blk[i] = NULL; @@ -105,7 +107,8 @@ MSVCRT_wchar_t ** msvcrt_SnapshotOfEnvironmentW(MSVCRT_wchar_t **wblk) for (wptr = wenviron_strings; *wptr; wptr += strlenW(wptr) + 1) { - count++; + /* Don't count environment variables starting with '=' which are command shell specific */ + if (*wptr != '=') count++; len += strlenW(wptr) + 1; } if (wblk) @@ -119,7 +122,8 @@ MSVCRT_wchar_t ** msvcrt_SnapshotOfEnvironmentW(MSVCRT_wchar_t **wblk) memcpy(&wblk[count],wenviron_strings,len * sizeof(MSVCRT_wchar_t)); for (wptr = (MSVCRT_wchar_t*)&wblk[count]; *wptr; wptr += strlenW(wptr) + 1) { - wblk[i++] = wptr; + /* Skip special environment strings set by the command shell */ + if (*wptr != '=') wblk[i++] = wptr; } } wblk[i] = NULL; -- 2.17.1

3 5

[PATCH 1/2] wineboot: Create user profile registry key
by Alex Henrie 25 Sep '18

25 Sep '18

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=15670 Signed-off-by: Alex Henrie <alexhenrie24(a)gmail.com> --- programs/wineboot/wineboot.c | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/programs/wineboot/wineboot.c b/programs/wineboot/wineboot.c index 075b4c8b08..043cc64ab6 100644 --- a/programs/wineboot/wineboot.c +++ b/programs/wineboot/wineboot.c @@ -81,6 +81,7 @@ #include <shobjidl.h> #include <shlwapi.h> #include <shellapi.h> +#include <sddl.h> #include "resource.h" WINE_DEFAULT_DEBUG_CHANNEL(wineboot); @@ -422,6 +423,31 @@ static void create_volatile_environment_registry_key(void) RegCloseKey( hkey ); } +/* create a profile key for the current user */ +static void create_user_profile_registry_key(void) +{ + WCHAR profile_key_path[512] = {'S','o','f','t','w','a','r','e','\\', + 'M','i','c','r','o','s','o','f','t','\\', + 'W','i','n','d','o','w','s',' ','N','T','\\', + 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\', + 'P','r','o','f','i','l','e','L','i','s','t','\\',0}; + HANDLE token; + char buffer[512]; + WCHAR *sid_str; + HKEY profile_key; + + OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token); + GetTokenInformation(token, TokenUser, buffer, sizeof(buffer), NULL); + ConvertSidToStringSidW(((TOKEN_USER *)buffer)->User.Sid, &sid_str); + strcatW(profile_key_path, sid_str); + LocalFree(sid_str); + + RegCreateKeyExW(HKEY_LOCAL_MACHINE, profile_key_path, 0, NULL, 0, KEY_WRITE, NULL, &profile_key, NULL); + + RegCloseKey(profile_key); + CloseHandle(token); +} + /* Performs the rename operations dictated in %SystemRoot%\Wininit.ini. * Returns FALSE if there was an error, or otherwise if all is ok. */ @@ -1247,6 +1273,7 @@ int main( int argc, char *argv[] ) if (init || update) update_wineprefix( update ); create_volatile_environment_registry_key(); + create_user_profile_registry_key(); ProcessRunKeys( HKEY_LOCAL_MACHINE, RunOnceW, TRUE, TRUE ); -- 2.19.0

2 2

[PATCH] testbot: Let VM scripts identify the last part of a patchset.
by Francois Gouget 25 Sep '18

25 Sep '18

For patchsets (and subsets thereof) the Engine calls GetPatchImpacts() at least once with only the last part. This allows it to know exactly what the last part modifies and thus what needs to be retested. However the VM scripts only have the full patchset so they don't know what the last part is. Thus they are forced to rerun every test touched by the full patchset. So the TestBot now adds a marker before the last part, allowing GetPatchImpacts() to identify it. Note that it does not use '---' as that marker may or may not be present depending on how the patch was formatted for emailing (and can be ambiguous too). Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- testbot/lib/WineTestBot/PatchUtils.pm | 76 +++++++++++++++------ testbot/lib/WineTestBot/Patches.pm | 5 +- testbot/lib/WineTestBot/PendingPatchSets.pm | 5 ++ 3 files changed, 60 insertions(+), 26 deletions(-) diff --git a/testbot/lib/WineTestBot/PatchUtils.pm b/testbot/lib/WineTestBot/PatchUtils.pm index b7307e527..f03cc40bb 100644 --- a/testbot/lib/WineTestBot/PatchUtils.pm +++ b/testbot/lib/WineTestBot/PatchUtils.pm @@ -31,7 +31,8 @@ the Wine builds. =cut use Exporter 'import'; -our @EXPORT = qw(GetPatchImpacts UpdateWineData GetBuildTimeout); +our @EXPORT = qw(GetPatchImpacts LastPartSeparator UpdateWineData + GetBuildTimeout); use List::Util qw(min max); @@ -150,6 +151,11 @@ my $IgnoredPathsRe = join('|', 'tools/winemaker/', ); +sub LastPartSeparator() +{ + return "===== TestBot: Last patchset part =====\n"; +} + sub _CreateTestInfo($$$) { my ($Impacts, $Root, $Dir) = @_; @@ -261,9 +267,9 @@ configure, whether it impacts the tests, etc. =back =cut -sub GetPatchImpacts($;$) +sub GetPatchImpacts($) { - my ($PatchFileName, $PastImpacts) = @_; + my ($PatchFileName) = @_; my $fh; return undef if (!open($fh, "<", $PatchFileName)); @@ -281,25 +287,7 @@ sub GetPatchImpacts($;$) }; _LoadWineFiles(); - if ($PastImpacts) - { - # Update the list of Wine files so we correctly recognize patchset parts - # that modify new Wine files. - my $WineFiles = $PastImpacts->{WineFiles} || $_WineFiles; - map { $Impacts->{WineFiles}->{$_} = 1 } keys %{$WineFiles}; - map { $Impacts->{WineFiles}->{$_} = 1 } keys %{$PastImpacts->{NewFiles}}; - map { delete $Impacts->{WineFiles}->{$_} } keys %{$PastImpacts->{DeletedFiles}}; - - foreach my $PastInfo (values %{$PastImpacts->{Tests}}) - { - foreach my $File (keys %{$PastInfo->{Files}}) - { - _HandleFile($Impacts, "$PastInfo->{Path}/$File", - $PastInfo->{Files}->{$File} eq "rm" ? "rm" : 0); - } - } - } - + my $PastImpacts; my ($Path, $Change); while (my $Line = <$fh>) { @@ -332,6 +320,50 @@ sub GetPatchImpacts($;$) $Path = undef; $Change = ""; } + elsif ($Line eq LastPartSeparator()) + { + # All the diffs so far belongs to previous parts of this patchset. + # But: + # - Only the last part must be taken into account to determine if a + # rebuild and testing is needed. + # - Yet if a rebuild is needed the previous parts' patches will impact + # the scope of the rebuild so that information must be preserved. + # So save current impacts in $PastImpacts and reset the current state. + $PastImpacts = {}; + + # Build a copy of the Wine files list reflecting the current situation. + $Impacts->{WineFiles} = { %$_WineFiles } if (!$Impacts->{WineFiles}); + map { $Impacts->{WineFiles}->{$_} = 1 } keys %{$Impacts->{NewFiles}}; + map { delete $Impacts->{WineFiles}->{$_} } keys %{$Impacts->{DeletedFiles}}; + $Impacts->{NewFiles} = {}; + $Impacts->{DeletedFiles} = {}; + + # The modules impacted by previous parts will still need to be built, + # but only if the last part justifies a build. So make a backup. + $PastImpacts->{BuildModules} = $Impacts->{BuildModules}; + $Impacts->{BuildModules} = {}; + + # Also backup the build-related fields. + foreach my $Field ("Autoconf", "MakeMakefiles", + "PatchedRoot", "PatchedModules", "PatchedTests") + { + $PastImpacts->{$Field} = $Impacts->{$Field}; + $Impacts->{$Field} = undef; + } + + # Reset the status of all test unit files to not modified. + foreach my $TestInfo (values %{$Impacts->{Tests}}) + { + foreach my $File (keys %{$TestInfo->{Files}}) + { + if ($TestInfo->{Files}->{$File} ne "rm") + { + $TestInfo->{Files}->{$File} = 0; + } + } + } + $Impacts->{ModuleUnitCount} = $Impacts->{TestUnitCount} = 0; + } else { $Path = undef; diff --git a/testbot/lib/WineTestBot/Patches.pm b/testbot/lib/WineTestBot/Patches.pm index 038754365..469fedcdc 100644 --- a/testbot/lib/WineTestBot/Patches.pm +++ b/testbot/lib/WineTestBot/Patches.pm @@ -132,10 +132,7 @@ sub Submit($$$) { my ($self, $PatchFileName, $IsSet) = @_; - my $PastImpacts; - $PastImpacts = GetPatchImpacts($PatchFileName) if ($IsSet); - my $Impacts = GetPatchImpacts("$DataDir/patches/" . $self->Id, $PastImpacts); - + my $Impacts = GetPatchImpacts($PatchFileName); if (!$Impacts->{PatchedRoot} and !$Impacts->{PatchedModules} and !$Impacts->{PatchedTests}) { diff --git a/testbot/lib/WineTestBot/PendingPatchSets.pm b/testbot/lib/WineTestBot/PendingPatchSets.pm index 3ac8c5350..286b39314 100644 --- a/testbot/lib/WineTestBot/PendingPatchSets.pm +++ b/testbot/lib/WineTestBot/PendingPatchSets.pm @@ -42,6 +42,7 @@ use WineTestBot::WineTestBotObjects; our @ISA = qw(WineTestBot::WineTestBotItem); use WineTestBot::Config; +use WineTestBot::PatchUtils; use WineTestBot::Utils; @@ -116,6 +117,10 @@ sub SubmitSubset($$$) last; } + if ($PartNo == $MaxPart and $PartNo > 1) + { + print $CombinedFile LastPartSeparator(); + } if (open(my $PartFile, "<" , "$DataDir/patches/" . $Part->Patch->Id)) { print $CombinedFile $_ for (<$PartFile>); -- 2.19.0

1 0

[PATCH v2] quartz/filtergraph: Improve HRESULT propagation from IFilterGraph2_Connect().
by Zebediah Figura 25 Sep '18

25 Sep '18

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/quartz/filtergraph.c | 11 +++++-- dlls/quartz/tests/filtergraph.c | 67 +++++++++++++++++++++++++++++++++++++++-- 2 files changed, 73 insertions(+), 5 deletions(-) diff --git a/dlls/quartz/filtergraph.c b/dlls/quartz/filtergraph.c index 0468cb5..c8e3c08 100644 --- a/dlls/quartz/filtergraph.c +++ b/dlls/quartz/filtergraph.c @@ -1181,7 +1181,11 @@ static HRESULT WINAPI FilterGraph2_Connect(IFilterGraph2 *iface, IPin *ppinOut, /* Try direct connection first */ hr = IPin_Connect(ppinOut, ppinIn, NULL); - if (SUCCEEDED(hr)) + + /* If direct connection succeeded, we should propagate that return value. + * If it returned VFW_E_NOT_CONNECTED or VFW_E_NO_AUDIO_HARDWARE, then don't + * even bother trying intermediate filters, since they won't succeed. */ + if (SUCCEEDED(hr) || hr == VFW_E_NOT_CONNECTED || hr == VFW_E_NO_AUDIO_HARDWARE) goto out; TRACE("Direct connection failed, trying to render using extra filters\n"); @@ -1379,6 +1383,9 @@ error: } } + if (FAILED(hr)) + hr = VFW_E_CANNOT_CONNECT; + IEnumMoniker_Release(pEnumMoniker); out: @@ -1391,7 +1398,7 @@ out: --This->recursioncount; LeaveCriticalSection(&This->cs); TRACE("--> %08x\n", hr); - return SUCCEEDED(hr) ? S_OK : hr; + return hr; } /* Render all output pins of the given filter. Helper for FilterGraph2_Render(). */ diff --git a/dlls/quartz/tests/filtergraph.c b/dlls/quartz/tests/filtergraph.c index 6c8b9fa..5693c86 100644 --- a/dlls/quartz/tests/filtergraph.c +++ b/dlls/quartz/tests/filtergraph.c @@ -609,7 +609,6 @@ static void test_render_run(const WCHAR *file) ok(!refs, "Graph has %u references\n", refs); hr = test_graph_builder_connect_file(filename); -todo_wine ok(hr == VFW_E_CANNOT_CONNECT, "got %#x\n", hr); } else @@ -776,6 +775,8 @@ struct testpin unsigned int type_count, enum_idx; AM_MEDIA_TYPE *request_mt, *accept_mt; + HRESULT Connect_hr; + HRESULT EnumMediaTypes_hr; HRESULT QueryInternalConnections_hr; }; @@ -964,6 +965,9 @@ static HRESULT WINAPI testpin_EnumMediaTypes(IPin *iface, IEnumMediaTypes **out) struct testpin *pin = impl_from_IPin(iface); if (winetest_debug > 1) trace("%p->EnumMediaTypes()\n", pin); + if (FAILED(pin->EnumMediaTypes_hr)) + return pin->EnumMediaTypes_hr; + *out = &pin->IEnumMediaTypes_iface; IEnumMediaTypes_AddRef(*out); pin->enum_idx = 0; @@ -1063,6 +1067,8 @@ static void testpin_init(struct testpin *pin, const IPinVtbl *vtbl, PIN_DIRECTIO pin->IEnumMediaTypes_iface.lpVtbl = &testenummt_vtbl; pin->ref = 1; pin->dir = dir; + pin->Connect_hr = S_OK; + pin->EnumMediaTypes_hr = S_OK; pin->QueryInternalConnections_hr = E_NOTIMPL; } @@ -1077,12 +1083,16 @@ static HRESULT WINAPI testsource_Connect(IPin *iface, IPin *peer, const AM_MEDIA HRESULT hr; if (winetest_debug > 1) trace("%p->Connect(%p)\n", pin, peer); + if (FAILED(pin->Connect_hr)) + return pin->Connect_hr; + ok(!mt, "Got media type %p.\n", mt); if (SUCCEEDED(hr = IPin_ReceiveConnection(peer, &pin->IPin_iface, pin->request_mt))) { pin->peer = peer; IPin_AddRef(peer); + return pin->Connect_hr; } return hr; } @@ -1711,12 +1721,50 @@ static void test_graph_builder_connect(void) IFilterGraph2_Disconnect(graph, source_pin.peer); IFilterGraph2_Disconnect(graph, &source_pin.IPin_iface); + for (source_pin.Connect_hr = 0x00040200; source_pin.Connect_hr <= 0x000402ff; + ++source_pin.Connect_hr) + { + hr = IFilterGraph2_Connect(graph, &source_pin.IPin_iface, &sink_pin.IPin_iface); + ok(hr == source_pin.Connect_hr, "Got hr %#x for Connect() hr %#x.\n", + hr, source_pin.Connect_hr); + ok(source_pin.peer == &sink_pin.IPin_iface, "Got peer %p.\n", source_pin.peer); + IFilterGraph2_Disconnect(graph, source_pin.peer); + IFilterGraph2_Disconnect(graph, &source_pin.IPin_iface); + } + source_pin.Connect_hr = S_OK; + sink_pin.accept_mt = &sink_type; hr = IFilterGraph2_Connect(graph, &source_pin.IPin_iface, &sink_pin.IPin_iface); -todo_wine ok(hr == VFW_E_CANNOT_CONNECT, "Got hr %#x.\n", hr); ok(!source_pin.peer, "Got peer %p.\n", source_pin.peer); + for (source_pin.Connect_hr = 0x80040200; source_pin.Connect_hr <= 0x800402ff; + ++source_pin.Connect_hr) + { + hr = IFilterGraph2_Connect(graph, &source_pin.IPin_iface, &sink_pin.IPin_iface); + if (source_pin.Connect_hr == VFW_E_NOT_CONNECTED + || source_pin.Connect_hr == VFW_E_NO_AUDIO_HARDWARE) + ok(hr == source_pin.Connect_hr, "Got hr %#x for Connect() hr %#x.\n", + hr, source_pin.Connect_hr); + else + ok(hr == VFW_E_CANNOT_CONNECT, "Got hr %#x for Connect() hr %#x.\n", + hr, source_pin.Connect_hr); + ok(!source_pin.peer, "Got peer %p.\n", source_pin.peer); + ok(!sink_pin.peer, "Got peer %p.\n", sink_pin.peer); + } + source_pin.Connect_hr = S_OK; + + for (source_pin.EnumMediaTypes_hr = 0x80040200; source_pin.EnumMediaTypes_hr <= 0x800402ff; + ++source_pin.EnumMediaTypes_hr) + { + hr = IFilterGraph2_Connect(graph, &source_pin.IPin_iface, &sink_pin.IPin_iface); + ok(hr == source_pin.EnumMediaTypes_hr, "Got hr %#x for EnumMediaTypes() hr %#x.\n", + hr, source_pin.EnumMediaTypes_hr); + ok(!source_pin.peer, "Got peer %p.\n", source_pin.peer); + ok(!sink_pin.peer, "Got peer %p.\n", sink_pin.peer); + } + source_pin.EnumMediaTypes_hr = S_OK; + /* Test usage of intermediate filters. Similarly to Render(), filters are * simply tried in enumeration order. */ @@ -1740,6 +1788,20 @@ todo_wine IFilterGraph2_Disconnect(graph, sink_pin.peer); IFilterGraph2_Disconnect(graph, &sink_pin.IPin_iface); + for (source_pin.Connect_hr = 0x00040200; source_pin.Connect_hr <= 0x000402ff; + ++source_pin.Connect_hr) + { + hr = IFilterGraph2_Connect(graph, &source_pin.IPin_iface, &sink_pin.IPin_iface); + ok(hr == S_OK, "Got hr %#x for Connect() hr %#x.\n", hr, source_pin.Connect_hr); + ok(source_pin.peer == &parser2_pins[0].IPin_iface, "Got peer %p.\n", source_pin.peer); + ok(sink_pin.peer == &parser2_pins[1].IPin_iface, "Got peer %p.\n", sink_pin.peer); + IFilterGraph2_Disconnect(graph, source_pin.peer); + IFilterGraph2_Disconnect(graph, &source_pin.IPin_iface); + IFilterGraph2_Disconnect(graph, sink_pin.peer); + IFilterGraph2_Disconnect(graph, &sink_pin.IPin_iface); + } + source_pin.Connect_hr = S_OK; + IFilterGraph2_RemoveFilter(graph, &parser1.IBaseFilter_iface); IFilterGraph2_AddFilter(graph, &parser1.IBaseFilter_iface, NULL); @@ -1805,7 +1867,6 @@ todo_wine parser1_pins[1].name[0] = '~'; hr = IFilterGraph2_Connect(graph, &source_pin.IPin_iface, &sink_pin.IPin_iface); -todo_wine ok(hr == VFW_E_CANNOT_CONNECT, "Got hr %#x.\n", hr); ok(!source_pin.peer, "Got peer %p.\n", source_pin.peer); -- 2.7.4

1 0

[PATCH 5/5] wined3d: Store the wined3d creation flags for NO3D adapters as well.
by Henri Verbeet 24 Sep '18

24 Sep '18

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/directx.c | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index abe81deb337..f7ef5c018fd 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2463,7 +2463,14 @@ static const struct wined3d_adapter_ops wined3d_adapter_no3d_ops = wined3d_adapter_no3d_create_context, }; -static BOOL wined3d_adapter_no3d_init(struct wined3d_adapter *adapter) +static void wined3d_adapter_no3d_init_d3d_info(struct wined3d_adapter *adapter, DWORD wined3d_creation_flags) +{ + struct wined3d_d3d_info *d3d_info = &adapter->d3d_info; + + d3d_info->wined3d_creation_flags = wined3d_creation_flags; +} + +static BOOL wined3d_adapter_no3d_init(struct wined3d_adapter *adapter, DWORD wined3d_creation_flags) { static const struct wined3d_gpu_description gpu_description = { @@ -2485,6 +2492,8 @@ static BOOL wined3d_adapter_no3d_init(struct wined3d_adapter *adapter) adapter->shader_backend = &none_shader_backend; adapter->adapter_ops = &wined3d_adapter_no3d_ops; + wined3d_adapter_no3d_init_d3d_info(adapter, wined3d_creation_flags); + return TRUE; } @@ -2510,7 +2519,7 @@ static BOOL wined3d_adapter_init(struct wined3d_adapter *adapter, unsigned int o adapter->formats = NULL; if (wined3d_creation_flags & WINED3D_NO3D) - return wined3d_adapter_no3d_init(adapter); + return wined3d_adapter_no3d_init(adapter, wined3d_creation_flags); return wined3d_adapter_gl_init(adapter, wined3d_creation_flags); } -- 2.11.0

1 0

[PATCH 4/5] ddraw: Reject creating DDSCAPS_VIDEOMEMORY surfaces with DDRAW_NO3D.
by Henri Verbeet 24 Sep '18

24 Sep '18

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/ddraw/surface.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/dlls/ddraw/surface.c b/dlls/ddraw/surface.c index cf09f9c1416..c51db7661ab 100644 --- a/dlls/ddraw/surface.c +++ b/dlls/ddraw/surface.c @@ -6122,8 +6122,9 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_ else if (desc->ddsCaps.dwCaps & DDSCAPS_3DDEVICE) usage = WINED3DUSAGE_RENDERTARGET; - if (SUCCEEDED(hr = wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT, - WINED3D_DEVICE_TYPE_HAL, mode.format_id, usage, WINED3D_RTYPE_TEXTURE_2D, wined3d_desc.format))) + if (!(ddraw->flags & DDRAW_NO3D) && SUCCEEDED(hr = wined3d_check_device_format(ddraw->wined3d, + WINED3DADAPTER_DEFAULT, WINED3D_DEVICE_TYPE_HAL, mode.format_id, + usage, WINED3D_RTYPE_TEXTURE_2D, wined3d_desc.format))) desc->ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY; else desc->ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY; @@ -6257,6 +6258,13 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_ return DDERR_NOCOLORKEYHW; } + if ((ddraw->flags & DDRAW_NO3D) && (desc->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)) + { + WARN("Video memory surfaces not supported without 3D support.\n"); + heap_free(texture); + return DDERR_NODIRECTDRAWHW; + } + if (desc->ddsCaps.dwCaps & (DDSCAPS_OVERLAY)) wined3d_desc.usage |= WINED3DUSAGE_OVERLAY; -- 2.11.0

1 0

[PATCH 3/5] wined3d: Do not report WINEDDSCAPS_VIDEOMEMORY for WINED3D_NO3D adapters.
by Henri Verbeet 24 Sep '18

24 Sep '18

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/directx.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 925a5bc9eb8..abe81deb337 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2389,24 +2389,24 @@ HRESULT CDECL wined3d_get_device_caps(const struct wined3d *wined3d, UINT adapte caps->ddraw_caps.ssb_color_key_caps = ckey_caps; caps->ddraw_caps.ssb_fx_caps = fx_caps; - caps->ddraw_caps.dds_caps = WINEDDSCAPS_ALPHA | - WINEDDSCAPS_BACKBUFFER | - WINEDDSCAPS_FLIP | - WINEDDSCAPS_FRONTBUFFER | - WINEDDSCAPS_OFFSCREENPLAIN | - WINEDDSCAPS_PALETTE | - WINEDDSCAPS_PRIMARYSURFACE | - WINEDDSCAPS_SYSTEMMEMORY | - WINEDDSCAPS_VIDEOMEMORY | - WINEDDSCAPS_VISIBLE; + caps->ddraw_caps.dds_caps = WINEDDSCAPS_ALPHA + | WINEDDSCAPS_BACKBUFFER + | WINEDDSCAPS_FLIP + | WINEDDSCAPS_FRONTBUFFER + | WINEDDSCAPS_OFFSCREENPLAIN + | WINEDDSCAPS_PALETTE + | WINEDDSCAPS_PRIMARYSURFACE + | WINEDDSCAPS_SYSTEMMEMORY + | WINEDDSCAPS_VISIBLE; if (!(wined3d->flags & WINED3D_NO3D)) { - caps->ddraw_caps.dds_caps |= WINEDDSCAPS_3DDEVICE | - WINEDDSCAPS_MIPMAP | - WINEDDSCAPS_TEXTURE | - WINEDDSCAPS_ZBUFFER; - caps->ddraw_caps.caps |= WINEDDCAPS_3D; + caps->ddraw_caps.dds_caps |= WINEDDSCAPS_3DDEVICE + | WINEDDSCAPS_MIPMAP + | WINEDDSCAPS_TEXTURE + | WINEDDSCAPS_VIDEOMEMORY + | WINEDDSCAPS_ZBUFFER; + caps->ddraw_caps.caps |= WINEDDCAPS_3D; } caps->shader_double_precision = d3d_info->shader_double_precision; -- 2.11.0

1 0

[PATCH 2/5] ddraw: Do not report IID_IDirect3DHALDevice in ddraw_find_device() with DDRAW_NO3D.
by Henri Verbeet 24 Sep '18

24 Sep '18

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/ddraw/ddraw.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/dlls/ddraw/ddraw.c b/dlls/ddraw/ddraw.c index 56a74cb3285..e9e06ee486f 100644 --- a/dlls/ddraw/ddraw.c +++ b/dlls/ddraw/ddraw.c @@ -4069,6 +4069,12 @@ static HRESULT ddraw_find_device(struct ddraw *ddraw, const D3DFINDDEVICESEARCH TRACE("Trying to match GUID %s.\n", debugstr_guid(&fds->guid)); + if ((ddraw->flags & DDRAW_NO3D) && IsEqualGUID(&fds->guid, &IID_IDirect3DHALDevice)) + { + WARN("HAL device not available without 3D support.\n"); + return DDERR_NOTFOUND; + } + for (i = 0; i < guid_count; ++i) { if (IsEqualGUID(guids[i], &fds->guid)) -- 2.11.0

1 0

[PATCH 1/5] d2d1: Introduce a debug helper for D2D1_POINT_2F.
by Henri Verbeet 24 Sep '18

24 Sep '18

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/d2d1/bitmap_render_target.c | 12 ++++++------ dlls/d2d1/brush.c | 8 ++++---- dlls/d2d1/d2d1_private.h | 7 +++++++ dlls/d2d1/dc_render_target.c | 12 ++++++------ dlls/d2d1/device.c | 29 +++++++++++++++-------------- dlls/d2d1/factory.c | 2 +- dlls/d2d1/geometry.c | 32 +++++++++++++++----------------- dlls/d2d1/hwnd_render_target.c | 12 ++++++------ 8 files changed, 60 insertions(+), 54 deletions(-) diff --git a/dlls/d2d1/bitmap_render_target.c b/dlls/d2d1/bitmap_render_target.c index 7411d488926..df5b013a0b5 100644 --- a/dlls/d2d1/bitmap_render_target.c +++ b/dlls/d2d1/bitmap_render_target.c @@ -218,8 +218,8 @@ static void STDMETHODCALLTYPE d2d_bitmap_render_target_DrawLine(ID2D1BitmapRende { struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); - TRACE("iface %p, p0 {%.8e, %.8e}, p1 {%.8e, %.8e}, brush %p, stroke_width %.8e, stroke_style %p.\n", - iface, p0.x, p0.y, p1.x, p1.y, brush, stroke_width, stroke_style); + TRACE("iface %p, p0 %s, p1 %s, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, debug_d2d_point_2f(&p0), debug_d2d_point_2f(&p1), brush, stroke_width, stroke_style); ID2D1RenderTarget_DrawLine(render_target->dxgi_target, p0, p1, brush, stroke_width, stroke_style); } @@ -364,8 +364,8 @@ static void STDMETHODCALLTYPE d2d_bitmap_render_target_DrawTextLayout(ID2D1Bitma { struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); - TRACE("iface %p, origin {%.8e, %.8e}, layout %p, brush %p, options %#x.\n", - iface, origin.x, origin.y, layout, brush, options); + TRACE("iface %p, origin %s, layout %p, brush %p, options %#x.\n", + iface, debug_d2d_point_2f(&origin), layout, brush, options); ID2D1RenderTarget_DrawTextLayout(render_target->dxgi_target, origin, layout, brush, options); } @@ -376,8 +376,8 @@ static void STDMETHODCALLTYPE d2d_bitmap_render_target_DrawGlyphRun(ID2D1BitmapR { struct d2d_bitmap_render_target *render_target = impl_from_ID2D1BitmapRenderTarget(iface); - TRACE("iface %p, baseline_origin {%.8e, %.8e}, glyph_run %p, brush %p, measuring_mode %#x.\n", - iface, baseline_origin.x, baseline_origin.y, glyph_run, brush, measuring_mode); + TRACE("iface %p, baseline_origin %s, glyph_run %p, brush %p, measuring_mode %#x.\n", + iface, debug_d2d_point_2f(&baseline_origin), glyph_run, brush, measuring_mode); ID2D1RenderTarget_DrawGlyphRun(render_target->dxgi_target, baseline_origin, glyph_run, brush, measuring_mode); diff --git a/dlls/d2d1/brush.c b/dlls/d2d1/brush.c index 30a4235cdab..9c73ae1d88f 100644 --- a/dlls/d2d1/brush.c +++ b/dlls/d2d1/brush.c @@ -502,7 +502,7 @@ static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetStartPoint(ID2D1Linea { struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface); - TRACE("iface %p, start_point {%.8e, %.8e}.\n", iface, start_point.x, start_point.y); + TRACE("iface %p, start_point %s.\n", iface, debug_d2d_point_2f(&start_point)); brush->u.linear.start = start_point; } @@ -512,7 +512,7 @@ static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetEndPoint(ID2D1LinearG { struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface); - TRACE("iface %p, end_point {%.8e, %.8e}.\n", iface, end_point.x, end_point.y); + TRACE("iface %p, end_point %s.\n", iface, debug_d2d_point_2f(&end_point)); brush->u.linear.end = end_point; } @@ -689,7 +689,7 @@ static void STDMETHODCALLTYPE d2d_radial_gradient_brush_SetCenter(ID2D1RadialGra { struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); - TRACE("iface %p, centre {%.8e, %.8e}.\n", iface, centre.x, centre.y); + TRACE("iface %p, centre %s.\n", iface, debug_d2d_point_2f(&centre)); brush->u.radial.centre = centre; } @@ -699,7 +699,7 @@ static void STDMETHODCALLTYPE d2d_radial_gradient_brush_SetGradientOriginOffset( { struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface); - TRACE("iface %p, offset {%.8e, %.8e}.\n", iface, offset.x, offset.y); + TRACE("iface %p, offset %s.\n", iface, debug_d2d_point_2f(&offset)); brush->u.radial.offset = offset; } diff --git a/dlls/d2d1/d2d1_private.h b/dlls/d2d1/d2d1_private.h index 2d3acd59977..9bfbbf2a6c4 100644 --- a/dlls/d2d1/d2d1_private.h +++ b/dlls/d2d1/d2d1_private.h @@ -587,6 +587,13 @@ static inline void d2d_rect_expand(D2D1_RECT_F *dst, const D2D1_POINT_2F *point) dst->bottom = point->y; } +static inline const char *debug_d2d_point_2f(const D2D1_POINT_2F *point) +{ + if (!point) + return "(null)"; + return wine_dbg_sprintf("{%.8e, %.8e}", point->x, point->y); +} + static inline const char *debug_d2d_rect_f(const D2D1_RECT_F *rect) { if (!rect) return "(null)"; diff --git a/dlls/d2d1/dc_render_target.c b/dlls/d2d1/dc_render_target.c index 050adf6dd6f..9a0f458fafe 100644 --- a/dlls/d2d1/dc_render_target.c +++ b/dlls/d2d1/dc_render_target.c @@ -247,8 +247,8 @@ static void STDMETHODCALLTYPE d2d_dc_render_target_DrawLine(ID2D1DCRenderTarget { struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); - TRACE("iface %p, p0 {%.8e, %.8e}, p1 {%.8e, %.8e}, brush %p, stroke_width %.8e, stroke_style %p.\n", - iface, p0.x, p0.y, p1.x, p1.y, brush, stroke_width, stroke_style); + TRACE("iface %p, p0 %s, p1 %s, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, debug_d2d_point_2f(&p0), debug_d2d_point_2f(&p1), brush, stroke_width, stroke_style); ID2D1RenderTarget_DrawLine(render_target->dxgi_target, p0, p1, brush, stroke_width, stroke_style); } @@ -393,8 +393,8 @@ static void STDMETHODCALLTYPE d2d_dc_render_target_DrawTextLayout(ID2D1DCRenderT { struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); - TRACE("iface %p, origin {%.8e, %.8e}, layout %p, brush %p, options %#x.\n", - iface, origin.x, origin.y, layout, brush, options); + TRACE("iface %p, origin %s, layout %p, brush %p, options %#x.\n", + iface, debug_d2d_point_2f(&origin), layout, brush, options); ID2D1RenderTarget_DrawTextLayout(render_target->dxgi_target, origin, layout, brush, options); } @@ -405,8 +405,8 @@ static void STDMETHODCALLTYPE d2d_dc_render_target_DrawGlyphRun(ID2D1DCRenderTar { struct d2d_dc_render_target *render_target = impl_from_ID2D1DCRenderTarget(iface); - TRACE("iface %p, baseline_origin {%.8e, %.8e}, glyph_run %p, brush %p, measuring_mode %#x.\n", - iface, baseline_origin.x, baseline_origin.y, glyph_run, brush, measuring_mode); + TRACE("iface %p, baseline_origin %s, glyph_run %p, brush %p, measuring_mode %#x.\n", + iface, debug_d2d_point_2f(&baseline_origin), glyph_run, brush, measuring_mode); ID2D1RenderTarget_DrawGlyphRun(render_target->dxgi_target, baseline_origin, glyph_run, brush, measuring_mode); diff --git a/dlls/d2d1/device.c b/dlls/d2d1/device.c index be8b7eab032..5e6655feba2 100644 --- a/dlls/d2d1/device.c +++ b/dlls/d2d1/device.c @@ -550,8 +550,8 @@ static void STDMETHODCALLTYPE d2d_device_context_DrawLine(ID2D1DeviceContext *if ID2D1GeometrySink *sink; HRESULT hr; - TRACE("iface %p, p0 {%.8e, %.8e}, p1 {%.8e, %.8e}, brush %p, stroke_width %.8e, stroke_style %p.\n", - iface, p0.x, p0.y, p1.x, p1.y, brush, stroke_width, stroke_style); + TRACE("iface %p, p0 %s, p1 %s, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, debug_d2d_point_2f(&p0), debug_d2d_point_2f(&p1), brush, stroke_width, stroke_style); if (FAILED(hr = ID2D1Factory_CreatePathGeometry(render_target->factory, &geometry))) { @@ -1108,8 +1108,8 @@ static void STDMETHODCALLTYPE d2d_device_context_DrawTextLayout(ID2D1DeviceConte struct d2d_draw_text_layout_ctx ctx; HRESULT hr; - TRACE("iface %p, origin {%.8e, %.8e}, layout %p, brush %p, options %#x.\n", - iface, origin.x, origin.y, layout, brush, options); + TRACE("iface %p, origin %s, layout %p, brush %p, options %#x.\n", + iface, debug_d2d_point_2f(&origin), layout, brush, options); ctx.brush = brush; ctx.options = options; @@ -1324,8 +1324,8 @@ static void STDMETHODCALLTYPE d2d_device_context_DrawGlyphRun(ID2D1DeviceContext DWRITE_RENDERING_MODE rendering_mode; HRESULT hr; - TRACE("iface %p, baseline_origin {%.8e, %.8e}, glyph_run %p, brush %p, measuring_mode %#x.\n", - iface, baseline_origin.x, baseline_origin.y, glyph_run, brush, measuring_mode); + TRACE("iface %p, baseline_origin %s, glyph_run %p, brush %p, measuring_mode %#x.\n", + iface, debug_d2d_point_2f(&baseline_origin), glyph_run, brush, measuring_mode); rendering_params = render_target->text_rendering_params ? render_target->text_rendering_params : render_target->default_text_rendering_params; @@ -1945,8 +1945,8 @@ static HRESULT STDMETHODCALLTYPE d2d_device_context_GetGlyphRunWorldBounds(ID2D1 D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, DWRITE_MEASURING_MODE measuring_mode, D2D1_RECT_F *bounds) { - FIXME("iface %p, baseline_origin {%.8e, %.8e}, glyph_run %p, measuring_mode %#x, bounds %p stub!\n", iface, - baseline_origin.x, baseline_origin.y, glyph_run, measuring_mode, bounds); + FIXME("iface %p, baseline_origin %s, glyph_run %p, measuring_mode %#x, bounds %p stub!\n", + iface, debug_d2d_point_2f(&baseline_origin), glyph_run, measuring_mode, bounds); return E_NOTIMPL; } @@ -2012,23 +2012,24 @@ static void STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_DrawGlyphRun D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, const DWRITE_GLYPH_RUN_DESCRIPTION *glyph_run_desc, ID2D1Brush *brush, DWRITE_MEASURING_MODE measuring_mode) { - FIXME("iface %p, baseline_origin {%.8e, %.8e}, glyph_run %p, " - "glyph_run_desc %p, brush %p, measuring_mode %#x stub!\n", - iface, baseline_origin.x, baseline_origin.y, glyph_run, glyph_run_desc, brush, measuring_mode); + FIXME("iface %p, baseline_origin %s, glyph_run %p, glyph_run_desc %p, brush %p, measuring_mode %#x stub!\n", + iface, debug_d2d_point_2f(&baseline_origin), glyph_run, glyph_run_desc, brush, measuring_mode); } static void STDMETHODCALLTYPE d2d_device_context_DrawImage(ID2D1DeviceContext *iface, ID2D1Image *image, const D2D1_POINT_2F *target_offset, const D2D1_RECT_F *image_rect, D2D1_INTERPOLATION_MODE interpolation_mode, D2D1_COMPOSITE_MODE composite_mode) { - FIXME("iface %p, image %p, target_offset %p, image_rect %s, interpolation_mode %#x, composite_mode %#x stub!\n", - iface, image, target_offset, debug_d2d_rect_f(image_rect), interpolation_mode, composite_mode); + FIXME("iface %p, image %p, target_offset %s, image_rect %s, interpolation_mode %#x, composite_mode %#x stub!\n", + iface, image, debug_d2d_point_2f(target_offset), debug_d2d_rect_f(image_rect), + interpolation_mode, composite_mode); } static void STDMETHODCALLTYPE d2d_device_context_DrawGdiMetafile(ID2D1DeviceContext *iface, ID2D1GdiMetafile *metafile, const D2D1_POINT_2F *target_offset) { - FIXME("iface %p, metafile %p, target_offset %p stub!\n", iface, metafile, target_offset); + FIXME("iface %p, metafile %p, target_offset %s stub!\n", + iface, metafile, debug_d2d_point_2f(target_offset)); } static void STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_DrawBitmap(ID2D1DeviceContext *iface, diff --git a/dlls/d2d1/factory.c b/dlls/d2d1/factory.c index 29038ec91ee..2459b58c03d 100644 --- a/dlls/d2d1/factory.c +++ b/dlls/d2d1/factory.c @@ -577,7 +577,7 @@ void WINAPI D2D1MakeRotateMatrix(float angle, D2D1_POINT_2F center, D2D1_MATRIX_ { float theta, sin_theta, cos_theta; - TRACE("angle %.8e, center {%.8e, %.8e}, matrix %p.\n", angle, center.x, center.y, matrix); + TRACE("angle %.8e, center %s, matrix %p.\n", angle, debug_d2d_point_2f(&center), matrix); theta = angle * (M_PI / 180.0f); sin_theta = sinf(theta); diff --git a/dlls/d2d1/geometry.c b/dlls/d2d1/geometry.c index d716fb128d7..421ba2b5515 100644 --- a/dlls/d2d1/geometry.c +++ b/dlls/d2d1/geometry.c @@ -2419,8 +2419,8 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_BeginFigure(ID2D1GeometrySink *i struct d2d_geometry *geometry = impl_from_ID2D1GeometrySink(iface); struct d2d_figure *figure; - TRACE("iface %p, start_point {%.8e, %.8e}, figure_begin %#x.\n", - iface, start_point.x, start_point.y, figure_begin); + TRACE("iface %p, start_point %s, figure_begin %#x.\n", + iface, debug_d2d_point_2f(&start_point), figure_begin); if (geometry->u.path.state != D2D_GEOMETRY_STATE_OPEN) { @@ -2882,7 +2882,7 @@ done: static void STDMETHODCALLTYPE d2d_geometry_sink_AddLine(ID2D1GeometrySink *iface, D2D1_POINT_2F point) { - TRACE("iface %p, point {%.8e, %.8e}.\n", iface, point.x, point.y); + TRACE("iface %p, point %s.\n", iface, debug_d2d_point_2f(&point)); d2d_geometry_sink_AddLines(iface, &point, 1); } @@ -3164,9 +3164,9 @@ static HRESULT STDMETHODCALLTYPE d2d_path_geometry_StrokeContainsPoint(ID2D1Path D2D1_POINT_2F point, float stroke_width, ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, float tolerance, BOOL *contains) { - FIXME("iface %p, point {%.8e, %.8e}, stroke_width %.8e, stroke_style %p, " + FIXME("iface %p, point %s, stroke_width %.8e, stroke_style %p, " "transform %p, tolerance %.8e, contains %p stub!\n", - iface, point.x, point.y, stroke_width, stroke_style, transform, tolerance, contains); + iface, debug_d2d_point_2f(&point), stroke_width, stroke_style, transform, tolerance, contains); return E_NOTIMPL; } @@ -3177,8 +3177,8 @@ static HRESULT STDMETHODCALLTYPE d2d_path_geometry_FillContainsPoint(ID2D1PathGe struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry(iface); D2D1_MATRIX_3X2_F g_i; - TRACE("iface %p, point {%.8e, %.8e}, transform %p, tolerance %.8e, contains %p.\n", - iface, point.x, point.y, transform, tolerance, contains); + TRACE("iface %p, point %s, transform %p, tolerance %.8e, contains %p.\n", + iface, debug_d2d_point_2f(&point), transform, tolerance, contains); if (transform) { @@ -3609,9 +3609,8 @@ static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_StrokeContainsPoint(ID2D D2D1_POINT_2F point, float stroke_width, ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, float tolerance, BOOL *contains) { - FIXME("iface %p, point {%.8e, %.8e}, stroke_width %.8e, stroke_style %p, " - "transform %p, tolerance %.8e, contains %p stub!\n", - iface, point.x, point.y, stroke_width, stroke_style, transform, tolerance, contains); + FIXME("iface %p, point %s, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, contains %p stub!\n", + iface, debug_d2d_point_2f(&point), stroke_width, stroke_style, transform, tolerance, contains); return E_NOTIMPL; } @@ -3623,8 +3622,8 @@ static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_FillContainsPoint(ID2D1R D2D1_RECT_F *rect = &geometry->u.rectangle.rect; float dx, dy; - TRACE("iface %p, point {%.8e, %.8e}, transform %p, tolerance %.8e, contains %p.\n", - iface, point.x, point.y, transform, tolerance, contains); + TRACE("iface %p, point %s, transform %p, tolerance %.8e, contains %p.\n", + iface, debug_d2d_point_2f(&point), transform, tolerance, contains); if (transform) { @@ -3939,9 +3938,8 @@ static HRESULT STDMETHODCALLTYPE d2d_transformed_geometry_StrokeContainsPoint(ID struct d2d_geometry *geometry = impl_from_ID2D1TransformedGeometry(iface); D2D1_MATRIX_3X2_F g; - TRACE("iface %p, point {%.8e, %.8e}, stroke_width %.8e, stroke_style %p, " - "transform %p, tolerance %.8e, contains %p.\n", - iface, point.x, point.y, stroke_width, stroke_style, transform, tolerance, contains); + TRACE("iface %p, point %s, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, contains %p.\n", + iface, debug_d2d_point_2f(&point), stroke_width, stroke_style, transform, tolerance, contains); g = geometry->transform; if (transform) @@ -3957,8 +3955,8 @@ static HRESULT STDMETHODCALLTYPE d2d_transformed_geometry_FillContainsPoint(ID2D struct d2d_geometry *geometry = impl_from_ID2D1TransformedGeometry(iface); D2D1_MATRIX_3X2_F g; - TRACE("iface %p, point {%.8e, %.8e}, transform %p, tolerance %.8e, contains %p.\n", - iface, point.x, point.y, transform, tolerance, contains); + TRACE("iface %p, point %s, transform %p, tolerance %.8e, contains %p.\n", + iface, debug_d2d_point_2f(&point), transform, tolerance, contains); g = geometry->transform; if (transform) diff --git a/dlls/d2d1/hwnd_render_target.c b/dlls/d2d1/hwnd_render_target.c index 2c9481e5768..9b8771f895d 100644 --- a/dlls/d2d1/hwnd_render_target.c +++ b/dlls/d2d1/hwnd_render_target.c @@ -233,8 +233,8 @@ static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawLine(ID2D1HwndRenderTar { struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); - TRACE("iface %p, p0 {%.8e, %.8e}, p1 {%.8e, %.8e}, brush %p, stroke_width %.8e, stroke_style %p.\n", - iface, p0.x, p0.y, p1.x, p1.y, brush, stroke_width, stroke_style); + TRACE("iface %p, p0 %s, p1 %s, brush %p, stroke_width %.8e, stroke_style %p.\n", + iface, debug_d2d_point_2f(&p0), debug_d2d_point_2f(&p1), brush, stroke_width, stroke_style); ID2D1RenderTarget_DrawLine(render_target->dxgi_target, p0, p1, brush, stroke_width, stroke_style); } @@ -379,8 +379,8 @@ static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawTextLayout(ID2D1HwndRen { struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); - TRACE("iface %p, origin {%.8e, %.8e}, layout %p, brush %p, options %#x.\n", - iface, origin.x, origin.y, layout, brush, options); + TRACE("iface %p, origin %s, layout %p, brush %p, options %#x.\n", + iface, debug_d2d_point_2f(&origin), layout, brush, options); ID2D1RenderTarget_DrawTextLayout(render_target->dxgi_target, origin, layout, brush, options); } @@ -391,8 +391,8 @@ static void STDMETHODCALLTYPE d2d_hwnd_render_target_DrawGlyphRun(ID2D1HwndRende { struct d2d_hwnd_render_target *render_target = impl_from_ID2D1HwndRenderTarget(iface); - TRACE("iface %p, baseline_origin {%.8e, %.8e}, glyph_run %p, brush %p, measuring_mode %#x.\n", - iface, baseline_origin.x, baseline_origin.y, glyph_run, brush, measuring_mode); + TRACE("iface %p, baseline_origin %s, glyph_run %p, brush %p, measuring_mode %#x.\n", + iface, debug_d2d_point_2f(&baseline_origin), glyph_run, brush, measuring_mode); ID2D1RenderTarget_DrawGlyphRun(render_target->dxgi_target, baseline_origin, glyph_run, brush, measuring_mode); -- 2.11.0

1 0

[PATCH 1/4] devenum: Factor friendly name and CLSID registration into register_codec().
by Zebediah Figura 24 Sep '18

24 Sep '18

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/devenum/createdevenum.c | 307 ++++++++++++++----------------------------- 1 file changed, 98 insertions(+), 209 deletions(-) diff --git a/dlls/devenum/createdevenum.c b/dlls/devenum/createdevenum.c index 8fbf323..ad1022e 100644 --- a/dlls/devenum/createdevenum.c +++ b/dlls/devenum/createdevenum.c @@ -104,11 +104,16 @@ static ULONG WINAPI DEVENUM_ICreateDevEnum_Release(ICreateDevEnum * iface) return 1; /* non-heap based object */ } -static HRESULT register_codec(const CLSID *class, const WCHAR *name, IMoniker **ret) +static HRESULT register_codec(const GUID *class, const WCHAR *name, + const GUID *clsid, const WCHAR *friendly_name, IPropertyBag **ret) { static const WCHAR deviceW[] = {'@','d','e','v','i','c','e',':','c','m',':',0}; + WCHAR guidstr[CHARS_IN_GUID]; IParseDisplayName *parser; + IPropertyBag *propbag; + IMoniker *mon; WCHAR *buffer; + VARIANT var; ULONG eaten; HRESULT hr; @@ -128,10 +133,36 @@ static HRESULT register_codec(const CLSID *class, const WCHAR *name, IMoniker ** strcatW(buffer, backslashW); strcatW(buffer, name); - hr = IParseDisplayName_ParseDisplayName(parser, NULL, buffer, &eaten, ret); + IParseDisplayName_ParseDisplayName(parser, NULL, buffer, &eaten, &mon); IParseDisplayName_Release(parser); heap_free(buffer); - return hr; + + IMoniker_BindToStorage(mon, NULL, NULL, &IID_IPropertyBag, (void **)&propbag); + IMoniker_Release(mon); + + V_VT(&var) = VT_BSTR; + V_BSTR(&var) = SysAllocString(friendly_name); + hr = IPropertyBag_Write(propbag, wszFriendlyName, &var); + VariantClear(&var); + if (FAILED(hr)) + { + IPropertyBag_Release(propbag); + return hr; + } + + V_VT(&var) = VT_BSTR; + StringFromGUID2(clsid, guidstr, ARRAY_SIZE(guidstr)); + V_BSTR(&var) = SysAllocString(guidstr); + hr = IPropertyBag_Write(propbag, clsidW, &var); + VariantClear(&var); + if (FAILED(hr)) + { + IPropertyBag_Release(propbag); + return hr; + } + + *ret = propbag; + return S_OK; } static void DEVENUM_ReadPinTypes(HKEY hkeyPinKey, REGFILTERPINS2 *rgPin) @@ -412,15 +443,18 @@ static void register_legacy_filters(void) IPropertyBag *prop_bag = NULL; WCHAR wszRegKey[MAX_PATH]; HKEY classkey = NULL; - IMoniker *mon = NULL; - VARIANT var = {}; REGFILTER2 rgf2; DWORD Type, len; + GUID clsid; if (RegEnumKeyExW(hkeyFilter, i, wszFilterSubkeyName, &cName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) continue; TRACE("Registering %s\n", debugstr_w(wszFilterSubkeyName)); + hr = CLSIDFromString(wszFilterSubkeyName, &clsid); + if (FAILED(hr)) + continue; + strcpyW(wszRegKey, clsidW); strcatW(wszRegKey, backslashW); strcatW(wszRegKey, wszFilterSubkeyName); @@ -428,40 +462,30 @@ static void register_legacy_filters(void) if (RegOpenKeyExW(HKEY_CLASSES_ROOT, wszRegKey, 0, KEY_READ, &classkey) != ERROR_SUCCESS) continue; - hr = register_codec(&CLSID_LegacyAmFilterCategory, wszFilterSubkeyName, &mon); - if (FAILED(hr)) goto cleanup; - - hr = IMoniker_BindToStorage(mon, NULL, NULL, &IID_IPropertyBag, (void **)&prop_bag); - if (FAILED(hr)) goto cleanup; - - /* write friendly name */ len = 0; - V_VT(&var) = VT_BSTR; if (!RegQueryValueExW(classkey, NULL, NULL, &Type, NULL, &len)) { WCHAR *friendlyname = heap_alloc(len); if (!friendlyname) - goto cleanup; + { + RegCloseKey(classkey); + continue; + } RegQueryValueExW(classkey, NULL, NULL, &Type, (BYTE *)friendlyname, &len); - V_BSTR(&var) = SysAllocStringLen(friendlyname, len/sizeof(WCHAR)); + + hr = register_codec(&CLSID_LegacyAmFilterCategory, wszFilterSubkeyName, + &clsid, friendlyname, &prop_bag); + heap_free(friendlyname); } else - V_BSTR(&var) = SysAllocString(wszFilterSubkeyName); - - if (!V_BSTR(&var)) - goto cleanup; - hr = IPropertyBag_Write(prop_bag, wszFriendlyName, &var); - if (FAILED(hr)) goto cleanup; - VariantClear(&var); - - /* write clsid */ - V_VT(&var) = VT_BSTR; - if (!(V_BSTR(&var) = SysAllocString(wszFilterSubkeyName))) - goto cleanup; - hr = IPropertyBag_Write(prop_bag, clsidW, &var); - if (FAILED(hr)) goto cleanup; - VariantClear(&var); + hr = register_codec(&CLSID_LegacyAmFilterCategory, wszFilterSubkeyName, + &clsid, wszFilterSubkeyName, &prop_bag); + if (FAILED(hr)) + { + RegCloseKey(classkey); + continue; + } /* write filter data */ rgf2.dwMerit = MERIT_NORMAL; @@ -473,11 +497,8 @@ static void register_legacy_filters(void) write_filter_data(prop_bag, &rgf2); -cleanup: - if (prop_bag) IPropertyBag_Release(prop_bag); - if (mon) IMoniker_Release(mon); + IPropertyBag_Release(prop_bag); RegCloseKey(classkey); - VariantClear(&var); free_regfilter2(&rgf2); } } @@ -495,50 +516,30 @@ static BOOL CALLBACK register_dsound_devices(GUID *guid, const WCHAR *desc, cons REGPINTYPES rgtypes = {0}; REGFILTER2 rgf = {0}; WCHAR clsid[CHARS_IN_GUID]; - IMoniker *mon = NULL; VARIANT var; HRESULT hr; hr = DEVENUM_CreateAMCategoryKey(&CLSID_AudioRendererCategory); - if (FAILED(hr)) goto cleanup; + if (FAILED(hr)) + return FALSE; - V_VT(&var) = VT_BSTR; if (guid) { WCHAR *name = heap_alloc(sizeof(defaultW) + strlenW(desc) * sizeof(WCHAR)); if (!name) - goto cleanup; + return FALSE; strcpyW(name, directsoundW); strcatW(name, desc); - V_BSTR(&var) = SysAllocString(name); + hr = register_codec(&CLSID_AudioRendererCategory, name, + &CLSID_DSoundRender, name, &prop_bag); heap_free(name); } else - V_BSTR(&var) = SysAllocString(defaultW); - - if (!V_BSTR(&var)) - goto cleanup; - - hr = register_codec(&CLSID_AudioRendererCategory, V_BSTR(&var), &mon); - if (FAILED(hr)) goto cleanup; - - hr = IMoniker_BindToStorage(mon, NULL, NULL, &IID_IPropertyBag, (void **)&prop_bag); - if (FAILED(hr)) goto cleanup; - - /* write friendly name */ - hr = IPropertyBag_Write(prop_bag, wszFriendlyName, &var); - if (FAILED(hr)) goto cleanup; - VariantClear(&var); - - /* write clsid */ - V_VT(&var) = VT_BSTR; - StringFromGUID2(&CLSID_DSoundRender, clsid, CHARS_IN_GUID); - if (!(V_BSTR(&var) = SysAllocString(clsid))) - goto cleanup; - hr = IPropertyBag_Write(prop_bag, clsidW, &var); - if (FAILED(hr)) goto cleanup; - VariantClear(&var); + hr = register_codec(&CLSID_AudioRendererCategory, defaultW, + &CLSID_DSoundRender, defaultW, &prop_bag); + if (FAILED(hr)) + return FALSE; /* write filter data */ rgf.dwVersion = 2; @@ -557,16 +558,11 @@ static BOOL CALLBACK register_dsound_devices(GUID *guid, const WCHAR *desc, cons /* write DSound guid */ V_VT(&var) = VT_BSTR; StringFromGUID2(guid ? guid : &GUID_NULL, clsid, CHARS_IN_GUID); - if (!(V_BSTR(&var) = SysAllocString(clsid))) - goto cleanup; - hr = IPropertyBag_Write(prop_bag, dsguidW, &var); - if (FAILED(hr)) goto cleanup; + if ((V_BSTR(&var) = SysAllocString(clsid))) + hr = IPropertyBag_Write(prop_bag, dsguidW, &var); -cleanup: VariantClear(&var); - if (prop_bag) IPropertyBag_Release(prop_bag); - if (mon) IMoniker_Release(mon); - + IPropertyBag_Release(prop_bag); return TRUE; } @@ -578,9 +574,8 @@ static void register_waveout_devices(void) REGFILTERPINS2 rgpins = {0}; REGPINTYPES rgtypes = {0}; REGFILTER2 rgf = {0}; - WCHAR clsid[CHARS_IN_GUID]; - IMoniker *mon = NULL; WAVEOUTCAPSW caps; + const WCHAR *name; int i, count; VARIANT var; HRESULT hr; @@ -594,34 +589,12 @@ static void register_waveout_devices(void) { waveOutGetDevCapsW(i, &caps, sizeof(caps)); - V_VT(&var) = VT_BSTR; + name = (i == -1) ? defaultW : caps.szPname; - if (i == -1) /* WAVE_MAPPER */ - V_BSTR(&var) = SysAllocString(defaultW); - else - V_BSTR(&var) = SysAllocString(caps.szPname); - if (!(V_BSTR(&var))) - goto cleanup; - - hr = register_codec(&CLSID_AudioRendererCategory, V_BSTR(&var), &mon); - if (FAILED(hr)) goto cleanup; - - hr = IMoniker_BindToStorage(mon, NULL, NULL, &IID_IPropertyBag, (void **)&prop_bag); - if (FAILED(hr)) goto cleanup; - - /* write friendly name */ - hr = IPropertyBag_Write(prop_bag, wszFriendlyName, &var); - if (FAILED(hr)) goto cleanup; - VariantClear(&var); - - /* write clsid */ - V_VT(&var) = VT_BSTR; - StringFromGUID2(&CLSID_AudioRender, clsid, CHARS_IN_GUID); - if (!(V_BSTR(&var) = SysAllocString(clsid))) - goto cleanup; - hr = IPropertyBag_Write(prop_bag, clsidW, &var); - if (FAILED(hr)) goto cleanup; - VariantClear(&var); + hr = register_codec(&CLSID_AudioRendererCategory, name, + &CLSID_AudioRender, name, &prop_bag); + if (FAILED(hr)) + continue; /* write filter data */ rgf.dwVersion = 2; @@ -639,13 +612,10 @@ static void register_waveout_devices(void) /* write WaveOutId */ V_VT(&var) = VT_I4; V_I4(&var) = i; - hr = IPropertyBag_Write(prop_bag, waveoutidW, &var); - if (FAILED(hr)) goto cleanup; + IPropertyBag_Write(prop_bag, waveoutidW, &var); -cleanup: VariantClear(&var); if (prop_bag) IPropertyBag_Release(prop_bag); - if (mon) IMoniker_Release(mon); } } @@ -654,8 +624,6 @@ static void register_wavein_devices(void) static const WCHAR waveinidW[] = {'W','a','v','e','I','n','I','d',0}; IPropertyBag *prop_bag = NULL; REGFILTER2 rgf = {0}; - WCHAR clsid[CHARS_IN_GUID]; - IMoniker *mon = NULL; WAVEINCAPSW caps; int i, count; VARIANT var; @@ -670,31 +638,10 @@ static void register_wavein_devices(void) { waveInGetDevCapsW(i, &caps, sizeof(caps)); - V_VT(&var) = VT_BSTR; - - V_BSTR(&var) = SysAllocString(caps.szPname); - if (!(V_BSTR(&var))) - goto cleanup; - - hr = register_codec(&CLSID_AudioInputDeviceCategory, V_BSTR(&var), &mon); - if (FAILED(hr)) goto cleanup; - - hr = IMoniker_BindToStorage(mon, NULL, NULL, &IID_IPropertyBag, (void **)&prop_bag); - if (FAILED(hr)) goto cleanup; - - /* write friendly name */ - hr = IPropertyBag_Write(prop_bag, wszFriendlyName, &var); - if (FAILED(hr)) goto cleanup; - VariantClear(&var); - - /* write clsid */ - V_VT(&var) = VT_BSTR; - StringFromGUID2(&CLSID_AudioRecord, clsid, CHARS_IN_GUID); - if (!(V_BSTR(&var) = SysAllocString(clsid))) - goto cleanup; - hr = IPropertyBag_Write(prop_bag, clsidW, &var); - if (FAILED(hr)) goto cleanup; - VariantClear(&var); + hr = register_codec(&CLSID_AudioInputDeviceCategory, caps.szPname, + &CLSID_AudioRecord, caps.szPname, &prop_bag); + if (FAILED(hr)) + continue; /* write filter data */ rgf.dwVersion = 2; @@ -705,13 +652,10 @@ static void register_wavein_devices(void) /* write WaveInId */ V_VT(&var) = VT_I4; V_I4(&var) = i; - hr = IPropertyBag_Write(prop_bag, waveinidW, &var); - if (FAILED(hr)) goto cleanup; + IPropertyBag_Write(prop_bag, waveinidW, &var); -cleanup: VariantClear(&var); - if (prop_bag) IPropertyBag_Release(prop_bag); - if (mon) IMoniker_Release(mon); + IPropertyBag_Release(prop_bag); } } @@ -723,9 +667,8 @@ static void register_midiout_devices(void) REGFILTERPINS2 rgpins = {0}; REGPINTYPES rgtypes = {0}; REGFILTER2 rgf = {0}; - WCHAR clsid[CHARS_IN_GUID]; - IMoniker *mon = NULL; MIDIOUTCAPSW caps; + const WCHAR *name; int i, count; VARIANT var; HRESULT hr; @@ -739,34 +682,12 @@ static void register_midiout_devices(void) { midiOutGetDevCapsW(i, &caps, sizeof(caps)); - V_VT(&var) = VT_BSTR; + name = (i == -1) ? defaultW : caps.szPname; - if (i == -1) /* MIDI_MAPPER */ - V_BSTR(&var) = SysAllocString(defaultW); - else - V_BSTR(&var) = SysAllocString(caps.szPname); - if (!(V_BSTR(&var))) - goto cleanup; - - hr = register_codec(&CLSID_MidiRendererCategory, V_BSTR(&var), &mon); - if (FAILED(hr)) goto cleanup; - - hr = IMoniker_BindToStorage(mon, NULL, NULL, &IID_IPropertyBag, (void **)&prop_bag); - if (FAILED(hr)) goto cleanup; - - /* write friendly name */ - hr = IPropertyBag_Write(prop_bag, wszFriendlyName, &var); - if (FAILED(hr)) goto cleanup; - VariantClear(&var); - - /* write clsid */ - V_VT(&var) = VT_BSTR; - StringFromGUID2(&CLSID_AVIMIDIRender, clsid, CHARS_IN_GUID); - if (!(V_BSTR(&var) = SysAllocString(clsid))) - goto cleanup; - hr = IPropertyBag_Write(prop_bag, clsidW, &var); - if (FAILED(hr)) goto cleanup; - VariantClear(&var); + hr = register_codec(&CLSID_MidiRendererCategory, name, + &CLSID_AVIMIDIRender, name, &prop_bag); + if (FAILED(hr)) + continue; /* write filter data */ rgf.dwVersion = 2; @@ -784,13 +705,10 @@ static void register_midiout_devices(void) /* write MidiOutId */ V_VT(&var) = VT_I4; V_I4(&var) = i; - hr = IPropertyBag_Write(prop_bag, midioutidW, &var); - if (FAILED(hr)) goto cleanup; + IPropertyBag_Write(prop_bag, midioutidW, &var); -cleanup: VariantClear(&var); - if (prop_bag) IPropertyBag_Release(prop_bag); - if (mon) IMoniker_Release(mon); + IPropertyBag_Release(prop_bag); } } @@ -801,8 +719,6 @@ static void register_vfw_codecs(void) IPropertyBag *prop_bag = NULL; REGPINTYPES rgtypes[2]; REGFILTER2 rgf; - WCHAR clsid[CHARS_IN_GUID]; - IMoniker *mon = NULL; GUID typeguid; ICINFO info; VARIANT var; @@ -822,40 +738,10 @@ static void register_vfw_codecs(void) ICGetInfo(hic, &info, sizeof(info)); ICClose(hic); - V_VT(&var) = VT_BSTR; - - V_BSTR(&var) = SysAllocString(name); - if (!(V_BSTR(&var))) - goto cleanup; - - hr = register_codec(&CLSID_VideoCompressorCategory, V_BSTR(&var), &mon); - if (FAILED(hr)) goto cleanup; - - hr = IMoniker_BindToStorage(mon, NULL, NULL, &IID_IPropertyBag, (void **)&prop_bag); - if (FAILED(hr)) goto cleanup; - - /* write WaveInId */ - hr = IPropertyBag_Write(prop_bag, fcchandlerW, &var); - if (FAILED(hr)) goto cleanup; - VariantClear(&var); - - /* write friendly name */ - V_VT(&var) = VT_BSTR; - if (!(V_BSTR(&var) = SysAllocString(info.szDescription))) - goto cleanup; - - hr = IPropertyBag_Write(prop_bag, wszFriendlyName, &var); - if (FAILED(hr)) goto cleanup; - VariantClear(&var); - - /* write clsid */ - V_VT(&var) = VT_BSTR; - StringFromGUID2(&CLSID_AVICo, clsid, CHARS_IN_GUID); - if (!(V_BSTR(&var) = SysAllocString(clsid))) - goto cleanup; - hr = IPropertyBag_Write(prop_bag, clsidW, &var); - if (FAILED(hr)) goto cleanup; - VariantClear(&var); + hr = register_codec(&CLSID_VideoCompressorCategory, name, + &CLSID_AVICo, info.szDescription, &prop_bag); + if (FAILED(hr)) + continue; /* write filter data */ rgf.dwVersion = 2; @@ -877,10 +763,13 @@ static void register_vfw_codecs(void) write_filter_data(prop_bag, &rgf); -cleanup: + /* write WaveInId */ + V_VT(&var) = VT_BSTR; + V_BSTR(&var) = SysAllocString(name); + IPropertyBag_Write(prop_bag, fcchandlerW, &var); + VariantClear(&var); - if (prop_bag) IPropertyBag_Release(prop_bag); - if (mon) IMoniker_Release(mon); + IPropertyBag_Release(prop_bag); } } -- 2.7.4

2 4

[PATCH] riched20: Avoid using GCC's typeof extension
by Alex Henrie 24 Sep '18

24 Sep '18

Signed-off-by: Alex Henrie <alexhenrie24(a)gmail.com> --- dlls/riched20/txthost.c | 86 ++++++++++++++++++++--------------------- dlls/riched20/txtsrv.c | 4 +- 2 files changed, 45 insertions(+), 45 deletions(-) diff --git a/dlls/riched20/txthost.c b/dlls/riched20/txthost.c index b479bde81b..d929a1a0a3 100644 --- a/dlls/riched20/txthost.c +++ b/dlls/riched20/txthost.c @@ -501,9 +501,9 @@ DECLSPEC_HIDDEN HRESULT WINAPI ITextHostImpl_TxGetSelectionBarWidth(ITextHost *i #ifdef __i386__ /* thiscall functions are i386-specific */ -#define THISCALL(func) __thiscall_ ## func +#define THISCALL(func) (void *) __thiscall_ ## func #define DEFINE_THISCALL_WRAPPER(func,args) \ - extern typeof(func) THISCALL(func); \ + extern void * __thiscall_ ## func(void); \ __ASM_STDCALL_FUNC(__thiscall_ ## func, args, \ "popl %eax\n\t" \ "pushl %ecx\n\t" \ @@ -559,9 +559,9 @@ DEFINE_THISCALL_WRAPPER(ITextHostImpl_TxGetSelectionBarWidth,8) #ifdef __i386__ /* thiscall functions are i386-specific */ -#define STDCALL(func) __stdcall_ ## func +#define STDCALL(func) (void *) __stdcall_ ## func #define DEFINE_STDCALL_WRAPPER(num,func,args) \ - extern typeof(func) __stdcall_ ## func; \ + extern void * __stdcall_ ## func(void); \ __ASM_STDCALL_FUNC(__stdcall_ ## func, args, \ "popl %eax\n\t" \ "popl %ecx\n\t" \ @@ -613,45 +613,45 @@ const ITextHostVtbl itextHostStdcallVtbl = { NULL, NULL, NULL, - __stdcall_ITextHostImpl_TxGetDC, - __stdcall_ITextHostImpl_TxReleaseDC, - __stdcall_ITextHostImpl_TxShowScrollBar, - __stdcall_ITextHostImpl_TxEnableScrollBar, - __stdcall_ITextHostImpl_TxSetScrollRange, - __stdcall_ITextHostImpl_TxSetScrollPos, - __stdcall_ITextHostImpl_TxInvalidateRect, - __stdcall_ITextHostImpl_TxViewChange, - __stdcall_ITextHostImpl_TxCreateCaret, - __stdcall_ITextHostImpl_TxShowCaret, - __stdcall_ITextHostImpl_TxSetCaretPos, - __stdcall_ITextHostImpl_TxSetTimer, - __stdcall_ITextHostImpl_TxKillTimer, - __stdcall_ITextHostImpl_TxScrollWindowEx, - __stdcall_ITextHostImpl_TxSetCapture, - __stdcall_ITextHostImpl_TxSetFocus, - __stdcall_ITextHostImpl_TxSetCursor, - __stdcall_ITextHostImpl_TxScreenToClient, - __stdcall_ITextHostImpl_TxClientToScreen, - __stdcall_ITextHostImpl_TxActivate, - __stdcall_ITextHostImpl_TxDeactivate, - __stdcall_ITextHostImpl_TxGetClientRect, - __stdcall_ITextHostImpl_TxGetViewInset, - __stdcall_ITextHostImpl_TxGetCharFormat, - __stdcall_ITextHostImpl_TxGetParaFormat, - __stdcall_ITextHostImpl_TxGetSysColor, - __stdcall_ITextHostImpl_TxGetBackStyle, - __stdcall_ITextHostImpl_TxGetMaxLength, - __stdcall_ITextHostImpl_TxGetScrollBars, - __stdcall_ITextHostImpl_TxGetPasswordChar, - __stdcall_ITextHostImpl_TxGetAcceleratorPos, - __stdcall_ITextHostImpl_TxGetExtent, - __stdcall_ITextHostImpl_OnTxCharFormatChange, - __stdcall_ITextHostImpl_OnTxParaFormatChange, - __stdcall_ITextHostImpl_TxGetPropertyBits, - __stdcall_ITextHostImpl_TxNotify, - __stdcall_ITextHostImpl_TxImmGetContext, - __stdcall_ITextHostImpl_TxImmReleaseContext, - __stdcall_ITextHostImpl_TxGetSelectionBarWidth, + STDCALL(ITextHostImpl_TxGetDC), + STDCALL(ITextHostImpl_TxReleaseDC), + STDCALL(ITextHostImpl_TxShowScrollBar), + STDCALL(ITextHostImpl_TxEnableScrollBar), + STDCALL(ITextHostImpl_TxSetScrollRange), + STDCALL(ITextHostImpl_TxSetScrollPos), + STDCALL(ITextHostImpl_TxInvalidateRect), + STDCALL(ITextHostImpl_TxViewChange), + STDCALL(ITextHostImpl_TxCreateCaret), + STDCALL(ITextHostImpl_TxShowCaret), + STDCALL(ITextHostImpl_TxSetCaretPos), + STDCALL(ITextHostImpl_TxSetTimer), + STDCALL(ITextHostImpl_TxKillTimer), + STDCALL(ITextHostImpl_TxScrollWindowEx), + STDCALL(ITextHostImpl_TxSetCapture), + STDCALL(ITextHostImpl_TxSetFocus), + STDCALL(ITextHostImpl_TxSetCursor), + STDCALL(ITextHostImpl_TxScreenToClient), + STDCALL(ITextHostImpl_TxClientToScreen), + STDCALL(ITextHostImpl_TxActivate), + STDCALL(ITextHostImpl_TxDeactivate), + STDCALL(ITextHostImpl_TxGetClientRect), + STDCALL(ITextHostImpl_TxGetViewInset), + STDCALL(ITextHostImpl_TxGetCharFormat), + STDCALL(ITextHostImpl_TxGetParaFormat), + STDCALL(ITextHostImpl_TxGetSysColor), + STDCALL(ITextHostImpl_TxGetBackStyle), + STDCALL(ITextHostImpl_TxGetMaxLength), + STDCALL(ITextHostImpl_TxGetScrollBars), + STDCALL(ITextHostImpl_TxGetPasswordChar), + STDCALL(ITextHostImpl_TxGetAcceleratorPos), + STDCALL(ITextHostImpl_TxGetExtent), + STDCALL(ITextHostImpl_OnTxCharFormatChange), + STDCALL(ITextHostImpl_OnTxParaFormatChange), + STDCALL(ITextHostImpl_TxGetPropertyBits), + STDCALL(ITextHostImpl_TxNotify), + STDCALL(ITextHostImpl_TxImmGetContext), + STDCALL(ITextHostImpl_TxImmReleaseContext), + STDCALL(ITextHostImpl_TxGetSelectionBarWidth), }; #endif /* __i386__ */ diff --git a/dlls/riched20/txtsrv.c b/dlls/riched20/txtsrv.c index ee65621b1d..8cbe77431b 100644 --- a/dlls/riched20/txtsrv.c +++ b/dlls/riched20/txtsrv.c @@ -35,9 +35,9 @@ #ifdef __i386__ /* thiscall functions are i386-specific */ -#define THISCALL(func) __thiscall_ ## func +#define THISCALL(func) (void *) __thiscall_ ## func #define DEFINE_THISCALL_WRAPPER(func,args) \ - extern typeof(func) THISCALL(func); \ + extern void * __thiscall_ ## func(void); \ __ASM_STDCALL_FUNC(__thiscall_ ## func, args, \ "popl %eax\n\t" \ "pushl %ecx\n\t" \ -- 2.19.0

3 5

[PATCH] winedbg: In gdbproxy file, allow wine paths with spaces
by Andrew Eikum 24 Sep '18

24 Sep '18

Signed-off-by: Andrew Eikum <aeikum(a)codeweavers.com> --- I couldn't find a format specification for this file. It's loaded with "gdb -x $file", and this change seems to fix it for me with my gdb installation. programs/winedbg/gdbproxy.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c index 512e0112b9..025cb38131 100644 --- a/programs/winedbg/gdbproxy.c +++ b/programs/winedbg/gdbproxy.c @@ -1890,7 +1890,7 @@ static BOOL gdb_exec(const char* wine_path, unsigned port, unsigned flags) fd = mkstemps(buf, 0); if (fd == -1) return FALSE; if ((f = fdopen(fd, "w+")) == NULL) return FALSE; - fprintf(f, "file %s\n", wine_path); + fprintf(f, "file \"%s\"\n", wine_path); fprintf(f, "target remote localhost:%d\n", ntohs(port)); fprintf(f, "set prompt Wine-gdb>\\ \n"); /* gdb 5.1 seems to require it, won't hurt anyway */ -- 2.19.0

1 0

[PATCH 1/3] d2d1: Fix compatible target initialization.
by Nikolay Sivov 24 Sep '18

24 Sep '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/d2d1/bitmap_render_target.c | 8 +++- dlls/d2d1/device.c | 4 +- dlls/d2d1/tests/d2d1.c | 67 ++++++++++++++++++++++++++++++-- 3 files changed, 73 insertions(+), 6 deletions(-) diff --git a/dlls/d2d1/bitmap_render_target.c b/dlls/d2d1/bitmap_render_target.c index 57f5b23b51..6cea50972f 100644 --- a/dlls/d2d1/bitmap_render_target.c +++ b/dlls/d2d1/bitmap_render_target.c @@ -722,6 +722,11 @@ static const struct ID2D1BitmapRenderTargetVtbl d2d_bitmap_render_target_vtbl = d2d_bitmap_render_target_GetBitmap }; +static const struct d2d_device_context_ops d2d_bitmap_render_target_ops = +{ + NULL, +}; + HRESULT d2d_bitmap_render_target_init(struct d2d_bitmap_render_target *render_target, const struct d2d_device_context *parent_target, const D2D1_SIZE_F *size, const D2D1_SIZE_U *pixel_size, const D2D1_PIXEL_FORMAT *pixel_format, @@ -805,7 +810,8 @@ HRESULT d2d_bitmap_render_target_init(struct d2d_bitmap_render_target *render_ta } if (FAILED(hr = d2d_d3d_create_render_target(parent_target->factory, dxgi_surface, - (IUnknown *)&render_target->ID2D1BitmapRenderTarget_iface, NULL, + (IUnknown *)&render_target->ID2D1BitmapRenderTarget_iface, + parent_target->ops ? &d2d_bitmap_render_target_ops : NULL, &dxgi_rt_desc, (void **)&render_target->dxgi_inner))) { WARN("Failed to create DXGI surface render target, hr %#x.\n", hr); diff --git a/dlls/d2d1/device.c b/dlls/d2d1/device.c index d20377b5c2..f1d0dad45e 100644 --- a/dlls/d2d1/device.c +++ b/dlls/d2d1/device.c @@ -1515,7 +1515,7 @@ static HRESULT STDMETHODCALLTYPE d2d_device_context_Flush(ID2D1DeviceContext *if FIXME("iface %p, tag1 %p, tag2 %p stub!\n", iface, tag1, tag2); - if (context->ops) + if (context->ops && context->ops->device_context_present) context->ops->device_context_present(context->outer_unknown); return E_NOTIMPL; @@ -1693,7 +1693,7 @@ static HRESULT STDMETHODCALLTYPE d2d_device_context_EndDraw(ID2D1DeviceContext * if (tag2) *tag2 = context->error.tag2; - if (context->ops) + if (context->ops && context->ops->device_context_present) { if (FAILED(hr = context->ops->device_context_present(context->outer_unknown))) context->error.code = hr; diff --git a/dlls/d2d1/tests/d2d1.c b/dlls/d2d1/tests/d2d1.c index 4136b69885..9e6ce06543 100644 --- a/dlls/d2d1/tests/d2d1.c +++ b/dlls/d2d1/tests/d2d1.c @@ -6705,8 +6705,10 @@ static void check_rt_bitmap_surface_(unsigned int line, ID2D1RenderTarget *rt, B ID2D1RenderTarget *compatible_rt; IWICImagingFactory *wic_factory; ID2D1DeviceContext *context; + ID2D1DCRenderTarget *dc_rt; IWICBitmap *wic_bitmap; ID2D1Bitmap *bitmap; + ID2D1Image *target; D2D1_SIZE_U size; HRESULT hr; @@ -6749,13 +6751,37 @@ static void check_rt_bitmap_surface_(unsigned int line, ID2D1RenderTarget *rt, B CoUninitialize(); - if (FAILED(ID2D1RenderTarget_QueryInterface(rt, &IID_ID2D1DeviceContext, (void **)&context))) + /* Compatible target follows its parent. */ + hr = ID2D1RenderTarget_QueryInterface(rt, &IID_ID2D1DeviceContext, (void **)&context); + ok_(__FILE__, line)(SUCCEEDED(hr), "Failed to get device context, hr %#x.\n", hr); + + dc_rt = NULL; + ID2D1RenderTarget_QueryInterface(rt, &IID_ID2D1DCRenderTarget, (void **)&dc_rt); + + bitmap = NULL; + target = NULL; + ID2D1DeviceContext_GetTarget(context, &target); + if (target && FAILED(ID2D1Image_QueryInterface(target, &IID_ID2D1Bitmap, (void **)&bitmap))) + { + ID2D1Image_Release(target); + target = NULL; + } + if (bitmap) + ID2D1Bitmap_Release(bitmap); + + /* Pixel format is not defined until target is set, for DC target it's specified on creation. */ + if (target || dc_rt) { - /* Compatible target follows its parent. */ + ID2D1DeviceContext *context2; + hr = ID2D1RenderTarget_CreateCompatibleRenderTarget(rt, NULL, NULL, NULL, D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, (ID2D1BitmapRenderTarget **)&compatible_rt); ok_(__FILE__, line)(SUCCEEDED(hr), "Failed to create compatible render target, hr %#x.\n", hr); + hr = ID2D1RenderTarget_QueryInterface(compatible_rt, &IID_ID2D1DeviceContext, (void **)&context2); + ok_(__FILE__, line)(SUCCEEDED(hr), "Failed to get device context, hr %#x.\n", hr); + ID2D1DeviceContext_Release(context2); + hr = ID2D1RenderTarget_CreateBitmap(compatible_rt, size, bitmap_data, sizeof(*bitmap_data), &bitmap_desc, &bitmap); ok_(__FILE__, line)(SUCCEEDED(hr), "Failed to create bitmap, hr %#x.\n", hr); @@ -6765,7 +6791,18 @@ static void check_rt_bitmap_surface_(unsigned int line, ID2D1RenderTarget *rt, B ID2D1Bitmap_Release(bitmap); } else - ID2D1DeviceContext_Release(context); + { + hr = ID2D1RenderTarget_CreateCompatibleRenderTarget(rt, NULL, NULL, NULL, + D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, (ID2D1BitmapRenderTarget **)&compatible_rt); + todo_wine + ok_(__FILE__, line)(hr == WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT, " --- Unexpected hr %#x.\n", hr); + } + + ID2D1DeviceContext_Release(context); + if (target) + ID2D1Image_Release(target); + if (dc_rt) + ID2D1DCRenderTarget_Release(dc_rt); } static void test_bitmap_surface(void) @@ -6782,6 +6819,7 @@ static void test_bitmap_surface(void) IDXGISurface *surface; ID2D1Bitmap1 *bitmap; ID2D1Device *device; + ID2D1Image *target; HWND window; HRESULT hr; @@ -6809,7 +6847,23 @@ static void test_bitmap_surface(void) rt = create_render_target(surface); ok(!!rt, "Failed to create render target.\n"); + hr = ID2D1RenderTarget_QueryInterface(rt, &IID_ID2D1DeviceContext, (void **)&device_context); + ok(SUCCEEDED(hr), "Failed to get device context, hr %#x.\n", hr); + + bitmap = NULL; + ID2D1DeviceContext_GetTarget(device_context, (ID2D1Image **)&bitmap); +todo_wine + ok(!!bitmap, "Unexpected target.\n"); + +if (bitmap) +{ + check_bitmap_surface((ID2D1Bitmap *)bitmap, TRUE, D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW); + ID2D1Bitmap1_Release(bitmap); +} check_rt_bitmap_surface(rt, TRUE, D2D1_BITMAP_OPTIONS_NONE); + + ID2D1DeviceContext_Release(device_context); + ID2D1RenderTarget_Release(rt); /* Bitmap created from DXGI surface. */ @@ -6836,7 +6890,14 @@ if (SUCCEEDED(hr)) check_bitmap_surface((ID2D1Bitmap *)bitmap, TRUE, D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW); check_rt_bitmap_surface((ID2D1RenderTarget *)device_context, TRUE, D2D1_BITMAP_OPTIONS_NONE); + ID2D1DeviceContext_SetTarget(device_context, (ID2D1Image *)bitmap); + ID2D1DeviceContext_GetTarget(device_context, &target); + ok(target == (ID2D1Image *)bitmap, "Unexpected target.\n"); + + check_rt_bitmap_surface((ID2D1RenderTarget *)device_context, TRUE, D2D1_BITMAP_OPTIONS_NONE); + ID2D1DeviceContext_Release(device_context); + ID2D1Bitmap1_Release(bitmap); } ID2D1Device_Release(device); IDXGIDevice_Release(dxgi_device); -- 2.19.0

2 5

[PATCH 6/6] dxgi: Get rid of set_feature_level() from dxgi_device_layer.
by Józef Kucia 24 Sep '18

24 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/d3d11/d3d11_main.c | 18 +----------------- dlls/d3d11/d3d11_private.h | 2 -- dlls/d3d11/device.c | 2 ++ dlls/dxgi/device.c | 12 ------------ dlls/dxgi/dxgi_private.h | 2 -- dlls/dxgi/utils.c | 3 --- 6 files changed, 3 insertions(+), 36 deletions(-) diff --git a/dlls/d3d11/d3d11_main.c b/dlls/d3d11/d3d11_main.c index 6d981160f245..9c89820f6f53 100644 --- a/dlls/d3d11/d3d11_main.c +++ b/dlls/d3d11/d3d11_main.c @@ -95,27 +95,11 @@ static HRESULT WINAPI layer_create(enum dxgi_device_layer_id id, void **layer_ba return S_OK; } -static void WINAPI layer_set_feature_level(enum dxgi_device_layer_id id, void *device, - D3D_FEATURE_LEVEL feature_level) -{ - struct d3d_device *d3d_device = device; - - TRACE("id %#x, device %p, feature_level %#x.\n", id, device, feature_level); - - if (id != DXGI_DEVICE_LAYER_D3D10_DEVICE) - { - WARN("Unknown layer id %#x.\n", id); - return; - } - - d3d_device->feature_level = feature_level; -} - HRESULT WINAPI D3D11CoreRegisterLayers(void) { static const struct dxgi_device_layer layers[] = { - {DXGI_DEVICE_LAYER_D3D10_DEVICE, layer_init, layer_get_size, layer_create, layer_set_feature_level}, + {DXGI_DEVICE_LAYER_D3D10_DEVICE, layer_init, layer_get_size, layer_create}, }; DXGID3D10RegisterLayers(layers, ARRAY_SIZE(layers)); diff --git a/dlls/d3d11/d3d11_private.h b/dlls/d3d11/d3d11_private.h index 6ec413139cf6..3049193ce284 100644 --- a/dlls/d3d11/d3d11_private.h +++ b/dlls/d3d11/d3d11_private.h @@ -588,8 +588,6 @@ struct dxgi_device_layer UINT (WINAPI *get_size)(enum dxgi_device_layer_id id, struct layer_get_size_args *args, DWORD unknown0); HRESULT (WINAPI *create)(enum dxgi_device_layer_id id, void **layer_base, DWORD unknown0, void *device_object, REFIID riid, void **device_layer); - void (WINAPI *set_feature_level)(enum dxgi_device_layer_id id, void *device, - D3D_FEATURE_LEVEL feature_level); }; HRESULT WINAPI DXGID3D10CreateDevice(HMODULE d3d10core, IDXGIFactory *factory, IDXGIAdapter *adapter, diff --git a/dlls/d3d11/device.c b/dlls/d3d11/device.c index e6ba31c7c4b7..1edd41f0d404 100644 --- a/dlls/d3d11/device.c +++ b/dlls/d3d11/device.c @@ -6004,6 +6004,8 @@ static void CDECL device_parent_wined3d_device_created(struct wined3d_device_par wined3d_device_incref(wined3d_device); device->wined3d_device = wined3d_device; + device->feature_level = wined3d_device_get_feature_level(wined3d_device); + set_default_depth_stencil_state(wined3d_device); } diff --git a/dlls/dxgi/device.c b/dlls/dxgi/device.c index deb07ca0d821..51773e9c0054 100644 --- a/dlls/dxgi/device.c +++ b/dlls/dxgi/device.c @@ -411,7 +411,6 @@ HRESULT dxgi_device_init(struct dxgi_device *device, struct dxgi_device_layer *l IWineDXGIDeviceParent *dxgi_device_parent; struct dxgi_adapter *dxgi_adapter; struct dxgi_factory *dxgi_factory; - D3D_FEATURE_LEVEL feature_level; void *layer_base; HRESULT hr; @@ -455,15 +454,6 @@ HRESULT dxgi_device_init(struct dxgi_device *device, struct dxgi_device_layer *l wined3d_device_parent = IWineDXGIDeviceParent_get_wined3d_device_parent(dxgi_device_parent); IWineDXGIDeviceParent_Release(dxgi_device_parent); - if (!(feature_level = dxgi_check_feature_level_support(dxgi_factory, dxgi_adapter, - feature_levels, level_count))) - { - IUnknown_Release(device->child_layer); - wined3d_private_store_cleanup(&device->private_store); - wined3d_mutex_unlock(); - return E_FAIL; - } - if (FAILED(hr = wined3d_device_create(dxgi_factory->wined3d, dxgi_adapter->ordinal, WINED3D_DEVICE_TYPE_HAL, NULL, 0, 4, (const enum wined3d_feature_level *)feature_levels, level_count, @@ -476,8 +466,6 @@ HRESULT dxgi_device_init(struct dxgi_device *device, struct dxgi_device_layer *l return hr; } - layer->set_feature_level(layer->id, device->child_layer, feature_level); - memset(&swapchain_desc, 0, sizeof(swapchain_desc)); swapchain_desc.swap_effect = WINED3D_SWAP_EFFECT_DISCARD; swapchain_desc.device_window = dxgi_factory_get_device_window(dxgi_factory); diff --git a/dlls/dxgi/dxgi_private.h b/dlls/dxgi/dxgi_private.h index 3a59196e1abd..8c3e41a390bb 100644 --- a/dlls/dxgi/dxgi_private.h +++ b/dlls/dxgi/dxgi_private.h @@ -75,8 +75,6 @@ struct dxgi_device_layer UINT (WINAPI *get_size)(enum dxgi_device_layer_id id, struct layer_get_size_args *args, DWORD unknown0); HRESULT (WINAPI *create)(enum dxgi_device_layer_id id, void **layer_base, DWORD unknown0, void *device_object, REFIID riid, void **device_layer); - void (WINAPI *set_feature_level)(enum dxgi_device_layer_id id, void *device, - D3D_FEATURE_LEVEL feature_level); }; /* TRACE helper functions */ diff --git a/dlls/dxgi/utils.c b/dlls/dxgi/utils.c index 009d351f633f..ad8e2a23f2ae 100644 --- a/dlls/dxgi/utils.c +++ b/dlls/dxgi/utils.c @@ -23,7 +23,6 @@ #include "dxgi_private.h" WINE_DEFAULT_DEBUG_CHANNEL(dxgi); -WINE_DECLARE_DEBUG_CHANNEL(winediag); #define WINE_DXGI_TO_STR(x) case x: return #x @@ -674,7 +673,5 @@ D3D_FEATURE_LEVEL dxgi_check_feature_level_support(struct dxgi_factory *factory, debug_feature_level(feature_levels[i])); } - FIXME_(winediag)("None of the requested D3D feature levels is supported on this GPU " - "with the current shader backend.\n"); return 0; } -- 2.16.4

2 1

[PATCH 5/6] wined3d: Introduce wined3d_device_get_feature_level().
by Józef Kucia 24 Sep '18

24 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/device.c | 7 +++++++ dlls/wined3d/wined3d.spec | 1 + include/wine/wined3d.h | 1 + 3 files changed, 9 insertions(+) diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index 38c37d4c536d..922de369c85a 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -5026,6 +5026,13 @@ struct wined3d * CDECL wined3d_device_get_wined3d(const struct wined3d_device *d return device->wined3d; } +enum wined3d_feature_level CDECL wined3d_device_get_feature_level(const struct wined3d_device *device) +{ + TRACE("device %p.\n", device); + + return device->feature_level; +} + void CDECL wined3d_device_set_gamma_ramp(const struct wined3d_device *device, UINT swapchain_idx, DWORD flags, const struct wined3d_gamma_ramp *ramp) { diff --git a/dlls/wined3d/wined3d.spec b/dlls/wined3d/wined3d.spec index a401e04dcf3b..7944387bcab9 100644 --- a/dlls/wined3d/wined3d.spec +++ b/dlls/wined3d/wined3d.spec @@ -72,6 +72,7 @@ @ cdecl wined3d_device_get_domain_shader(ptr) @ cdecl wined3d_device_get_ds_resource_view(ptr long) @ cdecl wined3d_device_get_ds_sampler(ptr long) +@ cdecl wined3d_device_get_feature_level(ptr) @ cdecl wined3d_device_get_gamma_ramp(ptr long ptr) @ cdecl wined3d_device_get_geometry_shader(ptr) @ cdecl wined3d_device_get_gs_resource_view(ptr long) diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h index 6b81b3ab1df1..ef89caf0633f 100644 --- a/include/wine/wined3d.h +++ b/include/wine/wined3d.h @@ -2295,6 +2295,7 @@ struct wined3d_shader * __cdecl wined3d_device_get_domain_shader(const struct wi struct wined3d_shader_resource_view * __cdecl wined3d_device_get_ds_resource_view(const struct wined3d_device *device, unsigned int idx); struct wined3d_sampler * __cdecl wined3d_device_get_ds_sampler(const struct wined3d_device *device, unsigned int idx); +enum wined3d_feature_level __cdecl wined3d_device_get_feature_level(const struct wined3d_device *device); void __cdecl wined3d_device_get_gamma_ramp(const struct wined3d_device *device, UINT swapchain_idx, struct wined3d_gamma_ramp *ramp); struct wined3d_shader * __cdecl wined3d_device_get_geometry_shader(const struct wined3d_device *device); -- 2.16.4

2 1

[PATCH 4/6] wined3d: Pass feature levels to wined3d_device_create().
by Józef Kucia 24 Sep '18

24 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/d3d8/device.c | 14 +++++++++++--- dlls/d3d9/device.c | 14 +++++++++++++- dlls/ddraw/ddraw.c | 10 +++++++++- dlls/dxgi/device.c | 7 ++++--- dlls/dxgi/dxgi_private.h | 1 + dlls/wined3d/device.c | 31 +++++++++++++++++++++++++++++-- dlls/wined3d/directx.c | 20 +++++++++++--------- dlls/wined3d/utils.c | 22 ++++++++++++++++++++++ dlls/wined3d/wined3d.spec | 2 +- dlls/wined3d/wined3d_private.h | 6 +++++- include/wine/wined3d.h | 3 ++- 11 files changed, 108 insertions(+), 22 deletions(-) diff --git a/dlls/d3d8/device.c b/dlls/d3d8/device.c index 364798f79b3a..12d025383514 100644 --- a/dlls/d3d8/device.c +++ b/dlls/d3d8/device.c @@ -3399,6 +3399,14 @@ HRESULT device_init(struct d3d8_device *device, struct d3d8 *parent, struct wine struct wined3d_swapchain *wined3d_swapchain; HRESULT hr; + static const enum wined3d_feature_level feature_levels[] = + { + WINED3D_FEATURE_LEVEL_8, + WINED3D_FEATURE_LEVEL_7, + WINED3D_FEATURE_LEVEL_6, + WINED3D_FEATURE_LEVEL_5, + }; + device->IDirect3DDevice8_iface.lpVtbl = &d3d8_device_vtbl; device->device_parent.ops = &d3d8_wined3d_device_parent_ops; device->ref = 1; @@ -3413,9 +3421,9 @@ HRESULT device_init(struct d3d8_device *device, struct d3d8 *parent, struct wine if (!(flags & D3DCREATE_FPU_PRESERVE)) setup_fpu(); wined3d_mutex_lock(); - hr = wined3d_device_create(wined3d, adapter, device_type, focus_window, flags, 4, - &device->device_parent, &device->wined3d_device); - if (FAILED(hr)) + if (FAILED(hr = wined3d_device_create(wined3d, adapter, device_type, + focus_window, flags, 4, feature_levels, ARRAY_SIZE(feature_levels), + &device->device_parent, &device->wined3d_device))) { WARN("Failed to create wined3d device, hr %#x.\n", hr); wined3d_mutex_unlock(); diff --git a/dlls/d3d9/device.c b/dlls/d3d9/device.c index a8dc7097c487..a31360886b6a 100644 --- a/dlls/d3d9/device.c +++ b/dlls/d3d9/device.c @@ -4230,6 +4230,17 @@ HRESULT device_init(struct d3d9_device *device, struct d3d9 *parent, struct wine unsigned i, count = 1; HRESULT hr; + static const enum wined3d_feature_level feature_levels[] = + { + WINED3D_FEATURE_LEVEL_9_SM3, + WINED3D_FEATURE_LEVEL_9_SM2, + WINED3D_FEATURE_LEVEL_9_1, + WINED3D_FEATURE_LEVEL_8, + WINED3D_FEATURE_LEVEL_7, + WINED3D_FEATURE_LEVEL_6, + WINED3D_FEATURE_LEVEL_5, + }; + if (mode) FIXME("Ignoring display mode.\n"); @@ -4240,7 +4251,8 @@ HRESULT device_init(struct d3d9_device *device, struct d3d9 *parent, struct wine if (!(flags & D3DCREATE_FPU_PRESERVE)) setup_fpu(); wined3d_mutex_lock(); - if (FAILED(hr = wined3d_device_create(wined3d, adapter, device_type, focus_window, flags, 4, + if (FAILED(hr = wined3d_device_create(wined3d, adapter, device_type, + focus_window, flags, 4, feature_levels, ARRAY_SIZE(feature_levels), &device->device_parent, &device->wined3d_device))) { WARN("Failed to create wined3d device, hr %#x.\n", hr); diff --git a/dlls/ddraw/ddraw.c b/dlls/ddraw/ddraw.c index c83d0ca15689..56a74cb3285f 100644 --- a/dlls/ddraw/ddraw.c +++ b/dlls/ddraw/ddraw.c @@ -4986,6 +4986,13 @@ HRESULT ddraw_init(struct ddraw *ddraw, DWORD flags, enum wined3d_device_type de struct wined3d_caps caps; HRESULT hr; + static const enum wined3d_feature_level feature_levels[] = + { + WINED3D_FEATURE_LEVEL_7, + WINED3D_FEATURE_LEVEL_6, + WINED3D_FEATURE_LEVEL_5, + }; + ddraw->IDirectDraw7_iface.lpVtbl = &ddraw7_vtbl; ddraw->IDirectDraw_iface.lpVtbl = &ddraw1_vtbl; ddraw->IDirectDraw2_iface.lpVtbl = &ddraw2_vtbl; @@ -5023,7 +5030,8 @@ HRESULT ddraw_init(struct ddraw *ddraw, DWORD flags, enum wined3d_device_type de } if (FAILED(hr = wined3d_device_create(ddraw->wined3d, WINED3DADAPTER_DEFAULT, device_type, - NULL, 0, DDRAW_STRIDE_ALIGNMENT, &ddraw->device_parent, &ddraw->wined3d_device))) + NULL, 0, DDRAW_STRIDE_ALIGNMENT, feature_levels, ARRAY_SIZE(feature_levels), + &ddraw->device_parent, &ddraw->wined3d_device))) { WARN("Failed to create a wined3d device, hr %#x.\n", hr); wined3d_decref(ddraw->wined3d); diff --git a/dlls/dxgi/device.c b/dlls/dxgi/device.c index 67cadd5a3f89..deb07ca0d821 100644 --- a/dlls/dxgi/device.c +++ b/dlls/dxgi/device.c @@ -464,9 +464,10 @@ HRESULT dxgi_device_init(struct dxgi_device *device, struct dxgi_device_layer *l return E_FAIL; } - hr = wined3d_device_create(dxgi_factory->wined3d, dxgi_adapter->ordinal, WINED3D_DEVICE_TYPE_HAL, - NULL, 0, 4, wined3d_device_parent, &device->wined3d_device); - if (FAILED(hr)) + if (FAILED(hr = wined3d_device_create(dxgi_factory->wined3d, + dxgi_adapter->ordinal, WINED3D_DEVICE_TYPE_HAL, NULL, 0, 4, + (const enum wined3d_feature_level *)feature_levels, level_count, + wined3d_device_parent, &device->wined3d_device))) { WARN("Failed to create a wined3d device, returning %#x.\n", hr); IUnknown_Release(device->child_layer); diff --git a/dlls/dxgi/dxgi_private.h b/dlls/dxgi/dxgi_private.h index f74514f0d326..3a59196e1abd 100644 --- a/dlls/dxgi/dxgi_private.h +++ b/dlls/dxgi/dxgi_private.h @@ -97,6 +97,7 @@ DXGI_USAGE dxgi_usage_from_wined3d_usage(DWORD wined3d_usage) DECLSPEC_HIDDEN; DWORD wined3d_usage_from_dxgi_usage(DXGI_USAGE usage) DECLSPEC_HIDDEN; unsigned int dxgi_swapchain_flags_from_wined3d(unsigned int wined3d_flags) DECLSPEC_HIDDEN; unsigned int wined3d_swapchain_flags_from_dxgi(unsigned int flags) DECLSPEC_HIDDEN; + HRESULT dxgi_get_private_data(struct wined3d_private_store *store, REFGUID guid, UINT *data_size, void *data) DECLSPEC_HIDDEN; HRESULT dxgi_set_private_data(struct wined3d_private_store *store, diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index 3fc3ae557dc6..38c37d4c536d 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -5158,16 +5158,43 @@ static int wined3d_sampler_compare(const void *key, const struct wine_rb_entry * return memcmp(&sampler->desc, key, sizeof(sampler->desc)); } +static BOOL wined3d_select_feature_level(const struct wined3d_adapter *adapter, + const enum wined3d_feature_level *levels, unsigned int level_count, + enum wined3d_feature_level *selected_level) +{ + const struct wined3d_d3d_info *d3d_info = &adapter->d3d_info; + unsigned int i; + + for (i = 0; i < level_count; ++i) + { + if (levels[i] && d3d_info->feature_level >= levels[i]) + { + *selected_level = levels[i]; + return TRUE; + } + } + + FIXME_(winediag)("None of the requested D3D feature levels is supported on this GPU " + "with the current shader backend.\n"); + return FALSE; +} + HRESULT device_init(struct wined3d_device *device, struct wined3d *wined3d, UINT adapter_idx, enum wined3d_device_type device_type, HWND focus_window, DWORD flags, - BYTE surface_alignment, struct wined3d_device_parent *device_parent) + BYTE surface_alignment, const enum wined3d_feature_level *levels, unsigned int level_count, + struct wined3d_device_parent *device_parent) { struct wined3d_adapter *adapter = &wined3d->adapters[adapter_idx]; - const struct fragment_pipeline *fragment_pipeline; const struct wined3d_vertex_pipe_ops *vertex_pipeline; + const struct fragment_pipeline *fragment_pipeline; unsigned int i; HRESULT hr; + if (!wined3d_select_feature_level(adapter, levels, level_count, &device->feature_level)) + return E_FAIL; + + TRACE("Device feature level %s.\n", wined3d_debug_feature_level(device->feature_level)); + device->ref = 1; device->wined3d = wined3d; wined3d_incref(device->wined3d); diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 4e8afed0a938..b893e0541946 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2448,16 +2448,18 @@ HRESULT CDECL wined3d_get_device_caps(const struct wined3d *wined3d, UINT adapte return WINED3D_OK; } -HRESULT CDECL wined3d_device_create(struct wined3d *wined3d, UINT adapter_idx, enum wined3d_device_type device_type, - HWND focus_window, DWORD flags, BYTE surface_alignment, struct wined3d_device_parent *device_parent, - struct wined3d_device **device) +HRESULT CDECL wined3d_device_create(struct wined3d *wined3d, unsigned int adapter_idx, + enum wined3d_device_type device_type, HWND focus_window, DWORD flags, BYTE surface_alignment, + const enum wined3d_feature_level *feature_levels, unsigned int feature_level_count, + struct wined3d_device_parent *device_parent, struct wined3d_device **device) { struct wined3d_device *object; HRESULT hr; - TRACE("wined3d %p, adapter_idx %u, device_type %#x, focus_window %p, " - "flags %#x, surface_alignment %u, device_parent %p, device %p.\n", - wined3d, adapter_idx, device_type, focus_window, flags, surface_alignment, device_parent, device); + TRACE("wined3d %p, adapter_idx %u, device_type %#x, focus_window %p, flags %#x, " + "surface_alignment %u, feature_levels %p, feature_level_count %u, device_parent %p, device %p.\n", + wined3d, adapter_idx, device_type, focus_window, flags, surface_alignment, + feature_levels, feature_level_count, device_parent, device); if (adapter_idx >= wined3d->adapter_count) return WINED3DERR_INVALIDCALL; @@ -2465,9 +2467,9 @@ HRESULT CDECL wined3d_device_create(struct wined3d *wined3d, UINT adapter_idx, e if (!(object = heap_alloc_zero(sizeof(*object)))) return E_OUTOFMEMORY; - hr = device_init(object, wined3d, adapter_idx, device_type, - focus_window, flags, surface_alignment, device_parent); - if (FAILED(hr)) + if (FAILED(hr = device_init(object, wined3d, adapter_idx, + device_type, focus_window, flags, surface_alignment, + feature_levels, feature_level_count, device_parent))) { WARN("Failed to initialize device, hr %#x.\n", hr); heap_free(object); diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index bf32953032ea..23f5fd70c675 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -6243,6 +6243,28 @@ const char *wined3d_debug_location(DWORD location) return wine_dbg_sprintf("%s%s%s", prefix, buffer.str, suffix); } +const char *wined3d_debug_feature_level(enum wined3d_feature_level level) +{ + switch (level) + { +#define LEVEL_TO_STR(level) case level: return #level + LEVEL_TO_STR(WINED3D_FEATURE_LEVEL_5); + LEVEL_TO_STR(WINED3D_FEATURE_LEVEL_6); + LEVEL_TO_STR(WINED3D_FEATURE_LEVEL_7); + LEVEL_TO_STR(WINED3D_FEATURE_LEVEL_8); + LEVEL_TO_STR(WINED3D_FEATURE_LEVEL_9_1); + LEVEL_TO_STR(WINED3D_FEATURE_LEVEL_9_SM2); + LEVEL_TO_STR(WINED3D_FEATURE_LEVEL_9_SM3); + LEVEL_TO_STR(WINED3D_FEATURE_LEVEL_10); + LEVEL_TO_STR(WINED3D_FEATURE_LEVEL_10_1); + LEVEL_TO_STR(WINED3D_FEATURE_LEVEL_11); + LEVEL_TO_STR(WINED3D_FEATURE_LEVEL_11_1); +#undef LEVEL_TO_STR + default: + return wine_dbg_sprintf("%#x", level); + } +} + /* Print a floating point value with the %.8e format specifier, always using * '.' as decimal separator. */ void wined3d_ftoa(float value, char *s) diff --git a/dlls/wined3d/wined3d.spec b/dlls/wined3d/wined3d.spec index 93cecf0d3bb4..a401e04dcf3b 100644 --- a/dlls/wined3d/wined3d.spec +++ b/dlls/wined3d/wined3d.spec @@ -42,7 +42,7 @@ @ cdecl wined3d_device_copy_resource(ptr ptr ptr) @ cdecl wined3d_device_copy_sub_resource_region(ptr ptr long long long long ptr long ptr long) @ cdecl wined3d_device_copy_uav_counter(ptr ptr long ptr) -@ cdecl wined3d_device_create(ptr long long ptr long long ptr ptr) +@ cdecl wined3d_device_create(ptr long long ptr long long ptr long ptr ptr) @ cdecl wined3d_device_decref(ptr) @ cdecl wined3d_device_dispatch_compute(ptr long long long) @ cdecl wined3d_device_dispatch_compute_indirect(ptr ptr long) diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 637c7218c184..423dda83e731 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2981,6 +2981,8 @@ struct wined3d_device WORD padding2 : 16; + enum wined3d_feature_level feature_level; + struct wined3d_state state; struct wined3d_state *update_state; struct wined3d_stateblock *recording; @@ -3036,7 +3038,8 @@ BOOL device_context_add(struct wined3d_device *device, struct wined3d_context *c void device_context_remove(struct wined3d_device *device, struct wined3d_context *context) DECLSPEC_HIDDEN; HRESULT device_init(struct wined3d_device *device, struct wined3d *wined3d, UINT adapter_idx, enum wined3d_device_type device_type, HWND focus_window, DWORD flags, - BYTE surface_alignment, struct wined3d_device_parent *device_parent) DECLSPEC_HIDDEN; + BYTE surface_alignment, const enum wined3d_feature_level *levels, unsigned int level_count, + struct wined3d_device_parent *device_parent) DECLSPEC_HIDDEN; LRESULT device_process_message(struct wined3d_device *device, HWND window, BOOL unicode, UINT message, WPARAM wparam, LPARAM lparam, WNDPROC proc) DECLSPEC_HIDDEN; void device_resource_add(struct wined3d_device *device, struct wined3d_resource *resource) DECLSPEC_HIDDEN; @@ -3913,6 +3916,7 @@ const char *debug_ivec4(const struct wined3d_ivec4 *v) DECLSPEC_HIDDEN; const char *debug_uvec4(const struct wined3d_uvec4 *v) DECLSPEC_HIDDEN; const char *debug_shader_type(enum wined3d_shader_type shader_type) DECLSPEC_HIDDEN; const char *debug_vec4(const struct wined3d_vec4 *v) DECLSPEC_HIDDEN; +const char *wined3d_debug_feature_level(enum wined3d_feature_level level) DECLSPEC_HIDDEN; void dump_color_fixup_desc(struct color_fixup_desc fixup) DECLSPEC_HIDDEN; BOOL is_invalid_op(const struct wined3d_state *state, int stage, diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h index 17b0fd4c456d..6b81b3ab1df1 100644 --- a/include/wine/wined3d.h +++ b/include/wine/wined3d.h @@ -2248,8 +2248,9 @@ HRESULT __cdecl wined3d_device_copy_sub_resource_region(struct wined3d_device *d unsigned int src_sub_resource_idx, const struct wined3d_box *src_box, unsigned int flags); void __cdecl wined3d_device_copy_uav_counter(struct wined3d_device *device, struct wined3d_buffer *dst_buffer, unsigned int offset, struct wined3d_unordered_access_view *uav); -HRESULT __cdecl wined3d_device_create(struct wined3d *wined3d, UINT adapter_idx, +HRESULT __cdecl wined3d_device_create(struct wined3d *wined3d, unsigned int adapter_idx, enum wined3d_device_type device_type, HWND focus_window, DWORD behaviour_flags, BYTE surface_alignment, + const enum wined3d_feature_level *feature_levels, unsigned int feature_level_count, struct wined3d_device_parent *device_parent, struct wined3d_device **device); ULONG __cdecl wined3d_device_decref(struct wined3d_device *device); void __cdecl wined3d_device_dispatch_compute(struct wined3d_device *device, -- 2.16.4

2 1

[PATCH 3/6] wined3d: Add remaining feature levels.
by Józef Kucia 24 Sep '18

24 Sep '18

We still don't have proper and exhaustive checks for feature levels capabilities. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/dxgi/utils.c | 6 +++--- dlls/wined3d/adapter_gl.c | 6 +++++- include/wine/wined3d.h | 3 +++ 3 files changed, 11 insertions(+), 4 deletions(-) diff --git a/dlls/dxgi/utils.c b/dlls/dxgi/utils.c index e857a1f090f5..009d351f633f 100644 --- a/dlls/dxgi/utils.c +++ b/dlls/dxgi/utils.c @@ -626,11 +626,11 @@ static enum wined3d_feature_level wined3d_feature_level_from_d3d(D3D_FEATURE_LEV switch (feature_level) { case D3D_FEATURE_LEVEL_11_1: - return WINED3D_FEATURE_LEVEL_11; + return WINED3D_FEATURE_LEVEL_11_1; case D3D_FEATURE_LEVEL_11_0: return WINED3D_FEATURE_LEVEL_11; case D3D_FEATURE_LEVEL_10_1: - return WINED3D_FEATURE_LEVEL_10; + return WINED3D_FEATURE_LEVEL_10_1; case D3D_FEATURE_LEVEL_10_0: return WINED3D_FEATURE_LEVEL_10; case D3D_FEATURE_LEVEL_9_3: @@ -638,7 +638,7 @@ static enum wined3d_feature_level wined3d_feature_level_from_d3d(D3D_FEATURE_LEV case D3D_FEATURE_LEVEL_9_2: return WINED3D_FEATURE_LEVEL_9_SM2; case D3D_FEATURE_LEVEL_9_1: - return WINED3D_FEATURE_LEVEL_9_SM2; + return WINED3D_FEATURE_LEVEL_9_1; default: FIXME("Unhandled feature level %#x.\n", feature_level); return 0; diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index 0ee71fd63df5..1d360d104bf8 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -1256,10 +1256,14 @@ static enum wined3d_feature_level feature_level_from_caps(const struct wined3d_g if (shader_model >= 5 && gl_info->supported[ARB_DRAW_INDIRECT] && gl_info->supported[ARB_TEXTURE_COMPRESSION_BPTC]) - return WINED3D_FEATURE_LEVEL_11; + return WINED3D_FEATURE_LEVEL_11_1; if (shader_model >= 4) + { + if (gl_info->supported[ARB_TEXTURE_CUBE_MAP_ARRAY]) + return WINED3D_FEATURE_LEVEL_10_1; return WINED3D_FEATURE_LEVEL_10; + } } if (shader_model >= 3) diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h index 3c01f755d869..17b0fd4c456d 100644 --- a/include/wine/wined3d.h +++ b/include/wine/wined3d.h @@ -95,10 +95,13 @@ enum wined3d_feature_level WINED3D_FEATURE_LEVEL_6 = 0x6000, WINED3D_FEATURE_LEVEL_7 = 0x7000, WINED3D_FEATURE_LEVEL_8 = 0x8000, + WINED3D_FEATURE_LEVEL_9_1 = 0x9100, WINED3D_FEATURE_LEVEL_9_SM2 = 0x9200, WINED3D_FEATURE_LEVEL_9_SM3 = 0x9300, WINED3D_FEATURE_LEVEL_10 = 0xa000, + WINED3D_FEATURE_LEVEL_10_1 = 0xa100, WINED3D_FEATURE_LEVEL_11 = 0xb000, + WINED3D_FEATURE_LEVEL_11_1 = 0xb100, }; enum wined3d_degree_type -- 2.16.4

2 1

[PATCH 2/6] wined3d: Make feature level enum compatible with Direct3D enum.
by Józef Kucia 24 Sep '18

24 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/directx.c | 89 ++++++++++++++++++++++++++++++-------------------- include/wine/wined3d.h | 18 +++++----- 2 files changed, 62 insertions(+), 45 deletions(-) diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 89684477e685..4e8afed0a938 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -617,49 +617,52 @@ void wined3d_driver_info_init(struct wined3d_driver_info *driver_info, enum wined3d_pci_device wined3d_gpu_from_feature_level(enum wined3d_pci_vendor *vendor, enum wined3d_feature_level feature_level) { - unsigned int i; - - static const enum wined3d_pci_device card_fallback_nvidia[] = - { - CARD_NVIDIA_RIVA_128, /* D3D5 */ - CARD_NVIDIA_RIVA_TNT, /* D3D6 */ - CARD_NVIDIA_GEFORCE, /* D3D7 */ - CARD_NVIDIA_GEFORCE3, /* D3D8 */ - CARD_NVIDIA_GEFORCEFX_5800, /* D3D9_SM2 */ - CARD_NVIDIA_GEFORCE_6800, /* D3D9_SM3 */ - CARD_NVIDIA_GEFORCE_8800GTX, /* D3D10 */ - CARD_NVIDIA_GEFORCE_GTX470, /* D3D11 */ + static const struct wined3d_fallback_card + { + enum wined3d_feature_level feature_level; + enum wined3d_pci_device device_id; + } + card_fallback_nvidia[] = + { + {WINED3D_FEATURE_LEVEL_5, CARD_NVIDIA_RIVA_128}, + {WINED3D_FEATURE_LEVEL_6, CARD_NVIDIA_RIVA_TNT}, + {WINED3D_FEATURE_LEVEL_7, CARD_NVIDIA_GEFORCE}, + {WINED3D_FEATURE_LEVEL_8, CARD_NVIDIA_GEFORCE3}, + {WINED3D_FEATURE_LEVEL_9_SM2, CARD_NVIDIA_GEFORCEFX_5800}, + {WINED3D_FEATURE_LEVEL_9_SM3, CARD_NVIDIA_GEFORCE_6800}, + {WINED3D_FEATURE_LEVEL_10, CARD_NVIDIA_GEFORCE_8800GTX}, + {WINED3D_FEATURE_LEVEL_11, CARD_NVIDIA_GEFORCE_GTX470}, + {WINED3D_FEATURE_LEVEL_NONE}, }, card_fallback_amd[] = { - CARD_AMD_RAGE_128PRO, /* D3D5 */ - CARD_AMD_RAGE_128PRO, /* D3D6 */ - CARD_AMD_RADEON_7200, /* D3D7 */ - CARD_AMD_RADEON_8500, /* D3D8 */ - CARD_AMD_RADEON_9500, /* D3D9_SM2 */ - CARD_AMD_RADEON_X1600, /* D3D9_SM3 */ - CARD_AMD_RADEON_HD2900, /* D3D10 */ - CARD_AMD_RADEON_HD5600, /* D3D11 */ + {WINED3D_FEATURE_LEVEL_5, CARD_AMD_RAGE_128PRO}, + {WINED3D_FEATURE_LEVEL_6, CARD_AMD_RAGE_128PRO}, + {WINED3D_FEATURE_LEVEL_7, CARD_AMD_RADEON_7200}, + {WINED3D_FEATURE_LEVEL_8, CARD_AMD_RADEON_8500}, + {WINED3D_FEATURE_LEVEL_9_SM2, CARD_AMD_RADEON_9500}, + {WINED3D_FEATURE_LEVEL_9_SM3, CARD_AMD_RADEON_X1600}, + {WINED3D_FEATURE_LEVEL_10, CARD_AMD_RADEON_HD2900}, + {WINED3D_FEATURE_LEVEL_11, CARD_AMD_RADEON_HD5600}, + {WINED3D_FEATURE_LEVEL_NONE}, }, card_fallback_intel[] = { - CARD_INTEL_845G, /* D3D5 */ - CARD_INTEL_845G, /* D3D6 */ - CARD_INTEL_845G, /* D3D7 */ - CARD_INTEL_915G, /* D3D8 */ - CARD_INTEL_915G, /* D3D9_SM2 */ - CARD_INTEL_945G, /* D3D9_SM3 */ - CARD_INTEL_G45, /* D3D10 */ - CARD_INTEL_IVBD, /* D3D11 */ + {WINED3D_FEATURE_LEVEL_5, CARD_INTEL_845G}, + {WINED3D_FEATURE_LEVEL_6, CARD_INTEL_845G}, + {WINED3D_FEATURE_LEVEL_7, CARD_INTEL_845G}, + {WINED3D_FEATURE_LEVEL_8, CARD_INTEL_915G}, + {WINED3D_FEATURE_LEVEL_9_SM2, CARD_INTEL_915G}, + {WINED3D_FEATURE_LEVEL_9_SM3, CARD_INTEL_945G}, + {WINED3D_FEATURE_LEVEL_10, CARD_INTEL_G45}, + {WINED3D_FEATURE_LEVEL_11, CARD_INTEL_IVBD}, + {WINED3D_FEATURE_LEVEL_NONE}, }; - C_ASSERT(ARRAY_SIZE(card_fallback_nvidia) == WINED3D_FEATURE_LEVEL_COUNT); - C_ASSERT(ARRAY_SIZE(card_fallback_amd) == WINED3D_FEATURE_LEVEL_COUNT); - C_ASSERT(ARRAY_SIZE(card_fallback_intel) == WINED3D_FEATURE_LEVEL_COUNT); static const struct { enum wined3d_pci_vendor vendor; - const enum wined3d_pci_device *device; + const struct wined3d_fallback_card *cards; } fallbacks[] = { @@ -669,15 +672,29 @@ enum wined3d_pci_device wined3d_gpu_from_feature_level(enum wined3d_pci_vendor * {HW_VENDOR_INTEL, card_fallback_intel}, }; + const struct wined3d_fallback_card *cards; + enum wined3d_pci_device device_id; + unsigned int i; + + cards = NULL; for (i = 0; i < ARRAY_SIZE(fallbacks); ++i) { if (*vendor == fallbacks[i].vendor) - return fallbacks[i].device[feature_level]; + cards = fallbacks[i].cards; + } + if (!cards) + { + *vendor = HW_VENDOR_NVIDIA; + cards = card_fallback_nvidia; } - *vendor = HW_VENDOR_NVIDIA; - - return card_fallback_nvidia[feature_level]; + device_id = cards->device_id; + for (i = 0; cards[i].feature_level; ++i) + { + if (feature_level >= cards[i].feature_level) + device_id = cards[i].device_id; + } + return device_id; } UINT CDECL wined3d_get_adapter_count(const struct wined3d *wined3d) diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h index ac7e3dd85cb4..3c01f755d869 100644 --- a/include/wine/wined3d.h +++ b/include/wine/wined3d.h @@ -90,15 +90,15 @@ enum wined3d_device_type enum wined3d_feature_level { - WINED3D_FEATURE_LEVEL_5, - WINED3D_FEATURE_LEVEL_6, - WINED3D_FEATURE_LEVEL_7, - WINED3D_FEATURE_LEVEL_8, - WINED3D_FEATURE_LEVEL_9_SM2, - WINED3D_FEATURE_LEVEL_9_SM3, - WINED3D_FEATURE_LEVEL_10, - WINED3D_FEATURE_LEVEL_11, - WINED3D_FEATURE_LEVEL_COUNT + WINED3D_FEATURE_LEVEL_NONE = 0x0000, + WINED3D_FEATURE_LEVEL_5 = 0x5000, + WINED3D_FEATURE_LEVEL_6 = 0x6000, + WINED3D_FEATURE_LEVEL_7 = 0x7000, + WINED3D_FEATURE_LEVEL_8 = 0x8000, + WINED3D_FEATURE_LEVEL_9_SM2 = 0x9200, + WINED3D_FEATURE_LEVEL_9_SM3 = 0x9300, + WINED3D_FEATURE_LEVEL_10 = 0xa000, + WINED3D_FEATURE_LEVEL_11 = 0xb000, }; enum wined3d_degree_type -- 2.16.4

2 1

[PATCH 1/6] dxgi: Introduce wined3d_feature_level_from_d3d() helper function.
by Józef Kucia 24 Sep '18

24 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/dxgi/utils.c | 75 ++++++++++++++++++++++++++----------------------------- 1 file changed, 36 insertions(+), 39 deletions(-) diff --git a/dlls/dxgi/utils.c b/dlls/dxgi/utils.c index aed62a4a3b36..e857a1f090f5 100644 --- a/dlls/dxgi/utils.c +++ b/dlls/dxgi/utils.c @@ -621,27 +621,36 @@ HRESULT dxgi_set_private_data_interface(struct wined3d_private_store *store, return hr; } -D3D_FEATURE_LEVEL dxgi_check_feature_level_support(struct dxgi_factory *factory, struct dxgi_adapter *adapter, - const D3D_FEATURE_LEVEL *feature_levels, unsigned int level_count) +static enum wined3d_feature_level wined3d_feature_level_from_d3d(D3D_FEATURE_LEVEL feature_level) { - static const struct + switch (feature_level) { - D3D_FEATURE_LEVEL d3d; - enum wined3d_feature_level wined3d; + case D3D_FEATURE_LEVEL_11_1: + return WINED3D_FEATURE_LEVEL_11; + case D3D_FEATURE_LEVEL_11_0: + return WINED3D_FEATURE_LEVEL_11; + case D3D_FEATURE_LEVEL_10_1: + return WINED3D_FEATURE_LEVEL_10; + case D3D_FEATURE_LEVEL_10_0: + return WINED3D_FEATURE_LEVEL_10; + case D3D_FEATURE_LEVEL_9_3: + return WINED3D_FEATURE_LEVEL_9_SM3; + case D3D_FEATURE_LEVEL_9_2: + return WINED3D_FEATURE_LEVEL_9_SM2; + case D3D_FEATURE_LEVEL_9_1: + return WINED3D_FEATURE_LEVEL_9_SM2; + default: + FIXME("Unhandled feature level %#x.\n", feature_level); + return 0; } - wined3d_feature_levels[] = - { - {D3D_FEATURE_LEVEL_11_1, WINED3D_FEATURE_LEVEL_11}, - {D3D_FEATURE_LEVEL_11_0, WINED3D_FEATURE_LEVEL_11}, - {D3D_FEATURE_LEVEL_10_1, WINED3D_FEATURE_LEVEL_10}, - {D3D_FEATURE_LEVEL_10_0, WINED3D_FEATURE_LEVEL_10}, - {D3D_FEATURE_LEVEL_9_3, WINED3D_FEATURE_LEVEL_9_SM3}, - {D3D_FEATURE_LEVEL_9_2, WINED3D_FEATURE_LEVEL_9_SM2}, - {D3D_FEATURE_LEVEL_9_1, WINED3D_FEATURE_LEVEL_9_SM2}, - }; - D3D_FEATURE_LEVEL selected_feature_level = 0; +} + +D3D_FEATURE_LEVEL dxgi_check_feature_level_support(struct dxgi_factory *factory, struct dxgi_adapter *adapter, + const D3D_FEATURE_LEVEL *feature_levels, unsigned int level_count) +{ + enum wined3d_feature_level wined3d_feature_level; struct wined3d_caps caps; - unsigned int i, j; + unsigned int i; HRESULT hr; wined3d_mutex_lock(); @@ -653,31 +662,19 @@ D3D_FEATURE_LEVEL dxgi_check_feature_level_support(struct dxgi_factory *factory, for (i = 0; i < level_count; ++i) { - for (j = 0; j < ARRAY_SIZE(wined3d_feature_levels); ++j) + wined3d_feature_level = wined3d_feature_level_from_d3d(feature_levels[i]); + if (wined3d_feature_level && caps.max_feature_level >= wined3d_feature_level) { - if (feature_levels[i] == wined3d_feature_levels[j].d3d) - { - if (caps.max_feature_level >= wined3d_feature_levels[j].wined3d) - { - selected_feature_level = feature_levels[i]; - TRACE("Choosing supported feature level %s.\n", - debug_feature_level(selected_feature_level)); - } - break; - } + TRACE("Choosing supported feature level %s.\n", + debug_feature_level(feature_levels[i])); + return feature_levels[i]; } - if (selected_feature_level) - break; - if (j == ARRAY_SIZE(wined3d_feature_levels)) - FIXME("Unexpected feature level %#x.\n", feature_levels[i]); - else - TRACE("Feature level %s not supported, trying next fallback if available.\n", - debug_feature_level(feature_levels[i])); + TRACE("Feature level %s not supported, trying next fallback if available.\n", + debug_feature_level(feature_levels[i])); } - if (!selected_feature_level) - FIXME_(winediag)("None of the requested D3D feature levels is supported on this GPU " - "with the current shader backend.\n"); - return selected_feature_level; + FIXME_(winediag)("None of the requested D3D feature levels is supported on this GPU " + "with the current shader backend.\n"); + return 0; } -- 2.16.4

2 1

[PATCH vkd3d 5/8] tests: Add tests for continue shader instructions.
by Józef Kucia 24 Sep '18

24 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- tests/d3d12.c | 88 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 88 insertions(+) diff --git a/tests/d3d12.c b/tests/d3d12.c index 9bb6861f7757..49e3b2371d4a 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -5632,6 +5632,84 @@ static void test_shader_instructions(void) 0x00004002, 0x3f800000, 0x00000000, 0x00000000, 0x3f800000, 0x0100003e, 0x01000015, 0x0100003e, }; static const D3D12_SHADER_BYTECODE ps_breakc_z = {ps_breakc_z_code, sizeof(ps_breakc_z_code)}; + static const DWORD ps_continue_code[] = + { +#if 0 + float4 main() : SV_TARGET + { + uint counter = 0; + + for (uint i = 0; i < 255; ++i) + { + if (i == 10) + continue; + ++counter; + } + + return float4(counter, 0.0f, 0.0f, 0.0f); + } +#endif + 0x43425844, 0x8cab8e1f, 0x527560f9, 0x04eb888b, 0x20d89b05, 0x00000001, 0x000001c4, 0x00000003, + 0x0000002c, 0x0000003c, 0x00000070, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, + 0x0000002c, 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000000, 0x00000003, 0x00000000, + 0x0000000f, 0x545f5653, 0x45475241, 0xabab0054, 0x58454853, 0x0000014c, 0x00000050, 0x00000053, + 0x0100086a, 0x03000065, 0x001020f2, 0x00000000, 0x02000068, 0x00000002, 0x05000036, 0x00100022, + 0x00000000, 0x00004001, 0x0000000b, 0x08000036, 0x001000c2, 0x00000000, 0x00004002, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x01000030, 0x07000050, 0x00100012, 0x00000001, 0x0010002a, + 0x00000000, 0x00004001, 0x000000ff, 0x03040003, 0x0010000a, 0x00000001, 0x07000020, 0x00100012, + 0x00000001, 0x0010002a, 0x00000000, 0x00004001, 0x0000000a, 0x0304001f, 0x0010000a, 0x00000001, + 0x05000036, 0x00100012, 0x00000000, 0x0010003a, 0x00000000, 0x05000036, 0x001000c2, 0x00000000, + 0x00100156, 0x00000000, 0x01000007, 0x01000015, 0x0700001e, 0x00100082, 0x00000000, 0x0010003a, + 0x00000000, 0x00004001, 0x00000001, 0x0700001e, 0x00100042, 0x00000000, 0x0010002a, 0x00000000, + 0x00004001, 0x00000001, 0x01000016, 0x05000056, 0x00102012, 0x00000000, 0x0010003a, 0x00000000, + 0x08000036, 0x001020e2, 0x00000000, 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x0100003e, + }; + static const D3D12_SHADER_BYTECODE ps_continue = {ps_continue_code, sizeof(ps_continue_code)}; + static const DWORD ps_continuec_nz_code[] = + { +#if 0 + float4 main() : SV_TARGET + { + uint counter = 0; + + for (uint i = 0; i < 255; ++i) + { + ++counter; + if (i % 2 == 0) + continue; + ++counter; + if (i != 0) + continue; + ++counter; + } + + return float4(counter, 0.0f, 0.0f, 0.0f); + } +#endif + /* compiled with /Gfa */ + 0x43425844, 0xf35d8ce6, 0x54988f56, 0x5848863e, 0xa1618498, 0x00000001, 0x00000278, 0x00000003, + 0x0000002c, 0x0000003c, 0x00000070, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, + 0x0000002c, 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000000, 0x00000003, 0x00000000, + 0x0000000f, 0x545f5653, 0x45475241, 0xabab0054, 0x58454853, 0x00000200, 0x00000050, 0x00000080, + 0x0100086a, 0x03000065, 0x001020f2, 0x00000000, 0x02000068, 0x00000002, 0x08000036, 0x00100032, + 0x00000000, 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x01000030, 0x07000050, + 0x00100042, 0x00000000, 0x0010001a, 0x00000000, 0x00004001, 0x000000ff, 0x03040003, 0x0010002a, + 0x00000000, 0x0700001e, 0x00100042, 0x00000000, 0x0010000a, 0x00000000, 0x00004001, 0x00000001, + 0x07000001, 0x00100082, 0x00000000, 0x0010001a, 0x00000000, 0x00004001, 0x00000001, 0x0700001e, + 0x00100012, 0x00000001, 0x0010001a, 0x00000000, 0x00004001, 0x00000001, 0x09000037, 0x00100022, + 0x00000001, 0x0010003a, 0x00000000, 0x0010001a, 0x00000000, 0x0010000a, 0x00000001, 0x05000036, + 0x00100012, 0x00000000, 0x0010002a, 0x00000000, 0x05000036, 0x00100022, 0x00000000, 0x0010001a, + 0x00000001, 0x03000008, 0x0010003a, 0x00000000, 0x0700001e, 0x00100042, 0x00000000, 0x0010000a, + 0x00000000, 0x00004001, 0x00000002, 0x07000027, 0x00100082, 0x00000000, 0x0010001a, 0x00000000, + 0x00004001, 0x00000000, 0x09000037, 0x00100022, 0x00000000, 0x0010001a, 0x00000000, 0x0010000a, + 0x00000001, 0x00004001, 0x00000000, 0x05000036, 0x00100032, 0x00000000, 0x00100a66, 0x00000000, + 0x03040008, 0x0010003a, 0x00000000, 0x0700001e, 0x00100012, 0x00000000, 0x0010000a, 0x00000000, + 0x00004001, 0x00000003, 0x05000036, 0x00100022, 0x00000000, 0x0010000a, 0x00000001, 0x01000016, + 0x05000056, 0x00102012, 0x00000000, 0x0010000a, 0x00000000, 0x08000036, 0x001020e2, 0x00000000, + 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0100003e, + }; + static const D3D12_SHADER_BYTECODE ps_continuec_nz = {ps_continuec_nz_code, sizeof(ps_continuec_nz_code)}; static const DWORD ps_src_modifiers_code[] = { #if 0 @@ -6646,6 +6724,7 @@ static void test_shader_instructions(void) struct uvec4 u; struct ivec4 i; } output; + bool skip_on_warp; } tests[] = { @@ -6733,6 +6812,9 @@ static void test_shader_instructions(void) {&ps_breakc_nz, {}, {{0.0f, 1.0f, 0.0f, 1.0f}}}, {&ps_breakc_z, {}, {{0.0f, 1.0f, 0.0f, 1.0f}}}, + {&ps_continue, {}, {{254.0f}}, TRUE}, + {&ps_continuec_nz, {}, {{509.0f}}}, + {&ps_src_modifiers, {{ 1.0f, 1.0f, 1.0f, 2.0f}}, {{-1.0f, 1.0f, -1.0f, -2.0f}}}, {&ps_src_modifiers, {{-1.0f, -1.0f, -1.0f, -2.0f}}, {{ 1.0f, 1.0f, -1.0f, -2.0f}}}, @@ -7384,6 +7466,12 @@ static void test_shader_instructions(void) current_ps = NULL; for (i = 0; i < ARRAY_SIZE(tests); ++i) { + if (tests[i].skip_on_warp && use_warp_device) + { + skip("Skipping shader test on WARP.\n"); + continue; + } + if (current_ps != tests[i].ps) { if (context.pipeline_state) -- 2.16.4

2 1

[PATCH vkd3d 7/8] vkd3d-shader: Translate gather4_c instructions.
by Józef Kucia 24 Sep '18

24 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d-shader/spirv.c | 43 +++++++++++++++++++++++++++++++------------ 1 file changed, 31 insertions(+), 12 deletions(-) diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index f3111477d43f..a183d653f225 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -1353,6 +1353,15 @@ static uint32_t vkd3d_spirv_build_op_image_gather(struct vkd3d_spirv_builder *bu operands, ARRAY_SIZE(operands), image_operands_mask, image_operands, image_operand_count); } +static uint32_t vkd3d_spirv_build_op_image_dref_gather(struct vkd3d_spirv_builder *builder, + uint32_t result_type, uint32_t sampled_image_id, uint32_t coordinate_id, uint32_t dref_id, + uint32_t image_operands_mask, const uint32_t *image_operands, unsigned int image_operand_count) +{ + const uint32_t operands[] = {sampled_image_id, coordinate_id, dref_id}; + return vkd3d_spirv_build_image_instruction(builder, SpvOpImageDrefGather, result_type, + operands, ARRAY_SIZE(operands), image_operands_mask, image_operands, image_operand_count); +} + static uint32_t vkd3d_spirv_build_op_image_fetch(struct vkd3d_spirv_builder *builder, uint32_t result_type, uint32_t image_id, uint32_t coordinate_id, uint32_t image_operands_mask, const uint32_t *image_operands, unsigned int image_operand_count) @@ -5415,7 +5424,7 @@ static void vkd3d_dxbc_compiler_emit_sample(struct vkd3d_dxbc_compiler *compiler static void vkd3d_dxbc_compiler_emit_sample_c(struct vkd3d_dxbc_compiler *compiler, const struct vkd3d_shader_instruction *instruction) { - uint32_t sampled_type_id, coordinate_id, ref_id, val_id, type_id; + uint32_t sampled_type_id, coordinate_id, dref_id, val_id, type_id; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; const struct vkd3d_shader_dst_param *dst = instruction->dst; const struct vkd3d_shader_src_param *src = instruction->src; @@ -5444,13 +5453,13 @@ static void vkd3d_dxbc_compiler_emit_sample_c(struct vkd3d_dxbc_compiler *compil &image, &src[1].reg, &src[2].reg, VKD3D_IMAGE_FLAG_DEPTH); sampled_type_id = vkd3d_spirv_get_type_id(builder, image.sampled_type, 1); coordinate_id = vkd3d_dxbc_compiler_emit_load_src(compiler, &src[0], VKD3DSP_WRITEMASK_ALL); - ref_id = vkd3d_dxbc_compiler_emit_load_src(compiler, &src[3], VKD3DSP_WRITEMASK_0); + dref_id = vkd3d_dxbc_compiler_emit_load_src(compiler, &src[3], VKD3DSP_WRITEMASK_0); /* XXX: Nvidia is broken and expects that the D_ref is packed together with coordinates. */ type_id = vkd3d_spirv_get_type_id(builder, VKD3D_TYPE_FLOAT, VKD3D_VEC4_SIZE); coordinate_id = vkd3d_spirv_build_op_composite_insert(builder, - type_id, ref_id, coordinate_id, &image.resource_type_info->coordinate_component_count, 1); + type_id, dref_id, coordinate_id, &image.resource_type_info->coordinate_component_count, 1); val_id = vkd3d_spirv_build_op_image_sample_dref(builder, op, sampled_type_id, - image.sampled_image_id, coordinate_id, ref_id, operands_mask, + image.sampled_image_id, coordinate_id, dref_id, operands_mask, image_operands, image_operand_count); vkd3d_dxbc_compiler_emit_store_dst_scalar(compiler, @@ -5460,8 +5469,8 @@ static void vkd3d_dxbc_compiler_emit_sample_c(struct vkd3d_dxbc_compiler *compil static void vkd3d_dxbc_compiler_emit_gather4(struct vkd3d_dxbc_compiler *compiler, const struct vkd3d_shader_instruction *instruction) { + uint32_t sampled_type_id, coordinate_id, component_id, dref_id, val_id; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; - uint32_t sampled_type_id, coordinate_id, component_id, val_id; const struct vkd3d_shader_dst_param *dst = instruction->dst; const struct vkd3d_shader_src_param *src = instruction->src; const struct vkd3d_shader_src_param *resource, *sampler; @@ -5475,10 +5484,6 @@ static void vkd3d_dxbc_compiler_emit_gather4(struct vkd3d_dxbc_compiler *compile resource = &src[1]; sampler = &src[2]; - component_idx = vkd3d_swizzle_get_component(sampler->swizzle, 0); - /* Nvidia driver requires signed integer type. */ - component_id = vkd3d_dxbc_compiler_get_constant(compiler, VKD3D_TYPE_INT, 1, &component_idx); - vkd3d_dxbc_compiler_prepare_sampled_image(compiler, &image, &resource->reg, &sampler->reg, VKD3D_IMAGE_FLAG_NONE); @@ -5492,9 +5497,22 @@ static void vkd3d_dxbc_compiler_emit_gather4(struct vkd3d_dxbc_compiler *compile sampled_type_id = vkd3d_spirv_get_type_id(builder, image.sampled_type, VKD3D_VEC4_SIZE); coordinate_mask = (1u << image.resource_type_info->coordinate_component_count) - 1; coordinate_id = vkd3d_dxbc_compiler_emit_load_src(compiler, &src[0], coordinate_mask); - val_id = vkd3d_spirv_build_op_image_gather(builder, sampled_type_id, - image.sampled_image_id, coordinate_id, component_id, - operands_mask, image_operands, image_operand_count); + if (instruction->handler_idx == VKD3DSIH_GATHER4_C) + { + dref_id = vkd3d_dxbc_compiler_emit_load_src(compiler, &src[3], VKD3DSP_WRITEMASK_0); + val_id = vkd3d_spirv_build_op_image_dref_gather(builder, sampled_type_id, + image.sampled_image_id, coordinate_id, dref_id, + operands_mask, image_operands, image_operand_count); + } + else + { + component_idx = vkd3d_swizzle_get_component(sampler->swizzle, 0); + /* Nvidia driver requires signed integer type. */ + component_id = vkd3d_dxbc_compiler_get_constant(compiler, VKD3D_TYPE_INT, 1, &component_idx); + val_id = vkd3d_spirv_build_op_image_gather(builder, sampled_type_id, + image.sampled_image_id, coordinate_id, component_id, + operands_mask, image_operands, image_operand_count); + } vkd3d_dxbc_compiler_emit_store_dst_swizzled(compiler, dst, val_id, image.sampled_type, resource->swizzle); @@ -6363,6 +6381,7 @@ void vkd3d_dxbc_compiler_handle_instruction(struct vkd3d_dxbc_compiler *compiler vkd3d_dxbc_compiler_emit_sample_c(compiler, instruction); break; case VKD3DSIH_GATHER4: + case VKD3DSIH_GATHER4_C: vkd3d_dxbc_compiler_emit_gather4(compiler, instruction); break; case VKD3DSIH_LD_RAW: -- 2.16.4

2 1

[PATCH vkd3d 8/8] vkd3d-shader: Translate gather4_po instructions.
by Józef Kucia 24 Sep '18

24 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d-shader/spirv.c | 30 +++++++++++++++++++++++------- tests/d3d12.c | 4 ++-- 2 files changed, 25 insertions(+), 9 deletions(-) diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index a183d653f225..a3e8c3977b38 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -5469,25 +5469,38 @@ static void vkd3d_dxbc_compiler_emit_sample_c(struct vkd3d_dxbc_compiler *compil static void vkd3d_dxbc_compiler_emit_gather4(struct vkd3d_dxbc_compiler *compiler, const struct vkd3d_shader_instruction *instruction) { + const struct vkd3d_shader_src_param *addr, *offset, *resource, *sampler; uint32_t sampled_type_id, coordinate_id, component_id, dref_id, val_id; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; const struct vkd3d_shader_dst_param *dst = instruction->dst; const struct vkd3d_shader_src_param *src = instruction->src; - const struct vkd3d_shader_src_param *resource, *sampler; SpvImageOperandsMask operands_mask = 0; unsigned int image_operand_count = 0; struct vkd3d_shader_image image; unsigned int component_idx; uint32_t image_operands[1]; DWORD coordinate_mask; + bool extended_offset; - resource = &src[1]; - sampler = &src[2]; + extended_offset = instruction->handler_idx == VKD3DSIH_GATHER4_PO + || instruction->handler_idx == VKD3DSIH_GATHER4_PO_C; + + addr = &src[0]; + offset = extended_offset ? &src[1] : NULL; + resource = &src[1 + extended_offset]; + sampler = &src[2 + extended_offset]; vkd3d_dxbc_compiler_prepare_sampled_image(compiler, &image, &resource->reg, &sampler->reg, VKD3D_IMAGE_FLAG_NONE); - if (vkd3d_shader_instruction_has_texel_offset(instruction)) + if (offset) + { + vkd3d_spirv_enable_capability(builder, SpvCapabilityImageGatherExtended); + operands_mask |= SpvImageOperandsOffsetMask; + image_operands[image_operand_count++] = vkd3d_dxbc_compiler_emit_load_src(compiler, + offset, (1u << image.resource_type_info->offset_component_count) - 1); + } + else if (vkd3d_shader_instruction_has_texel_offset(instruction)) { operands_mask |= SpvImageOperandsConstOffsetMask; image_operands[image_operand_count++] = vkd3d_dxbc_compiler_emit_texel_offset(compiler, @@ -5496,10 +5509,11 @@ static void vkd3d_dxbc_compiler_emit_gather4(struct vkd3d_dxbc_compiler *compile sampled_type_id = vkd3d_spirv_get_type_id(builder, image.sampled_type, VKD3D_VEC4_SIZE); coordinate_mask = (1u << image.resource_type_info->coordinate_component_count) - 1; - coordinate_id = vkd3d_dxbc_compiler_emit_load_src(compiler, &src[0], coordinate_mask); + coordinate_id = vkd3d_dxbc_compiler_emit_load_src(compiler, addr, coordinate_mask); if (instruction->handler_idx == VKD3DSIH_GATHER4_C) { - dref_id = vkd3d_dxbc_compiler_emit_load_src(compiler, &src[3], VKD3DSP_WRITEMASK_0); + dref_id = vkd3d_dxbc_compiler_emit_load_src(compiler, + &src[3 + extended_offset], VKD3DSP_WRITEMASK_0); val_id = vkd3d_spirv_build_op_image_dref_gather(builder, sampled_type_id, image.sampled_image_id, coordinate_id, dref_id, operands_mask, image_operands, image_operand_count); @@ -5508,7 +5522,8 @@ static void vkd3d_dxbc_compiler_emit_gather4(struct vkd3d_dxbc_compiler *compile { component_idx = vkd3d_swizzle_get_component(sampler->swizzle, 0); /* Nvidia driver requires signed integer type. */ - component_id = vkd3d_dxbc_compiler_get_constant(compiler, VKD3D_TYPE_INT, 1, &component_idx); + component_id = vkd3d_dxbc_compiler_get_constant(compiler, + VKD3D_TYPE_INT, 1, &component_idx); val_id = vkd3d_spirv_build_op_image_gather(builder, sampled_type_id, image.sampled_image_id, coordinate_id, component_id, operands_mask, image_operands, image_operand_count); @@ -6382,6 +6397,7 @@ void vkd3d_dxbc_compiler_handle_instruction(struct vkd3d_dxbc_compiler *compiler break; case VKD3DSIH_GATHER4: case VKD3DSIH_GATHER4_C: + case VKD3DSIH_GATHER4_PO: vkd3d_dxbc_compiler_emit_gather4(compiler, instruction); break; case VKD3DSIH_LD_RAW: diff --git a/tests/d3d12.c b/tests/d3d12.c index 49e3b2371d4a..5f2d2d8e50bf 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -9870,7 +9870,7 @@ static void test_gather(void) { const struct vec4 *expected = &expected_gather4_offset[y * rb.width + x]; const struct vec4 *got = get_readback_vec4(&rb, x, y); - todo(compare_vec4(got, expected, 0), + ok(compare_vec4(got, expected, 0), "Got {%.8e, %.8e, %.8e, %.8e}, expected {%.8e, %.8e, %.8e, %.8e}.\n", got->x, got->y, got->z, got->w, expected->x, expected->y, expected->z, expected->w); } @@ -9906,7 +9906,7 @@ static void test_gather(void) { const struct vec4 *expected = &expected_gather4[y * rb.width + x]; const struct vec4 *got = get_readback_vec4(&rb, x, y); - todo(compare_vec4(got, expected, 0), + ok(compare_vec4(got, expected, 0), "Got {%.8e, %.8e, %.8e, %.8e}, expected {%.8e, %.8e, %.8e, %.8e}.\n", got->x, got->y, got->z, got->w, expected->x, expected->y, expected->z, expected->w); } -- 2.16.4

2 1

[PATCH vkd3d 6/8] vkd3d-shader: Find innermost loops for breakc instructions.
by Józef Kucia 24 Sep '18

24 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d-shader/spirv.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 86f8ff62c6ca..f3111477d43f 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -5108,12 +5108,19 @@ static void vkd3d_dxbc_compiler_emit_control_flow_instruction(struct vkd3d_dxbc_ } case VKD3DSIH_BREAKP: - assert(compiler->control_flow_depth); - assert(cf_info->current_block == VKD3D_BLOCK_LOOP); + { + struct vkd3d_control_flow_info *loop_cf_info; + + if (!(loop_cf_info = vkd3d_dxbc_compiler_find_innermost_loop(compiler))) + { + ERR("Invalid 'breakc' instruction outside loop.\n"); + return; + } vkd3d_dxbc_compiler_emit_conditional_branch(compiler, - instruction, cf_info->u.loop.merge_block_id); + instruction, loop_cf_info->u.loop.merge_block_id); break; + } case VKD3DSIH_CONTINUE: { -- 2.16.4

2 1

[PATCH vkd3d 4/8] vkd3d-shader: Translate continuec instructions.
by Józef Kucia 24 Sep '18

24 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d-shader/spirv.c | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index b96b69e83934..86f8ff62c6ca 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -4761,7 +4761,7 @@ static void vkd3d_dxbc_compiler_emit_comparison_instruction(struct vkd3d_dxbc_co vkd3d_dxbc_compiler_emit_store_reg(compiler, &dst->reg, dst->write_mask, result_id); } -static void vkd3d_dxbc_compiler_emit_breakc(struct vkd3d_dxbc_compiler *compiler, +static void vkd3d_dxbc_compiler_emit_conditional_branch(struct vkd3d_dxbc_compiler *compiler, const struct vkd3d_shader_instruction *instruction, uint32_t target_block_id) { struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; @@ -5111,7 +5111,8 @@ static void vkd3d_dxbc_compiler_emit_control_flow_instruction(struct vkd3d_dxbc_ assert(compiler->control_flow_depth); assert(cf_info->current_block == VKD3D_BLOCK_LOOP); - vkd3d_dxbc_compiler_emit_breakc(compiler, instruction, cf_info->u.loop.merge_block_id); + vkd3d_dxbc_compiler_emit_conditional_branch(compiler, + instruction, cf_info->u.loop.merge_block_id); break; case VKD3DSIH_CONTINUE: @@ -5130,6 +5131,21 @@ static void vkd3d_dxbc_compiler_emit_control_flow_instruction(struct vkd3d_dxbc_ break; } + case VKD3DSIH_CONTINUEP: + { + struct vkd3d_control_flow_info *loop_cf_info; + + if (!(loop_cf_info = vkd3d_dxbc_compiler_find_innermost_loop(compiler))) + { + ERR("Invalid 'continuec' instruction outside loop.\n"); + return; + } + + vkd3d_dxbc_compiler_emit_conditional_branch(compiler, + instruction, loop_cf_info->u.loop.continue_block_id); + break; + } + case VKD3DSIH_RET: vkd3d_dxbc_compiler_emit_return(compiler, instruction); @@ -6307,6 +6323,7 @@ void vkd3d_dxbc_compiler_handle_instruction(struct vkd3d_dxbc_compiler *compiler case VKD3DSIH_BREAKP: case VKD3DSIH_CASE: case VKD3DSIH_CONTINUE: + case VKD3DSIH_CONTINUEP: case VKD3DSIH_DEFAULT: case VKD3DSIH_ELSE: case VKD3DSIH_ENDIF: -- 2.16.4

2 1

[PATCH vkd3d 3/8] vkd3d-shader: Translate continue instructions.
by Józef Kucia 24 Sep '18

24 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d-shader/spirv.c | 33 +++++++++++++++++++++++++++++++-- 1 file changed, 31 insertions(+), 2 deletions(-) diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index d19d89990d5c..b96b69e83934 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -4850,6 +4850,20 @@ static void vkd3d_dxbc_compiler_pop_control_flow_level(struct vkd3d_dxbc_compile memset(cf_info, 0, sizeof(*cf_info)); } +static struct vkd3d_control_flow_info *vkd3d_dxbc_compiler_find_innermost_loop( + struct vkd3d_dxbc_compiler *compiler) +{ + int depth; + + for (depth = compiler->control_flow_depth - 1; depth >= 0; --depth) + { + if (compiler->control_flow_info[depth].current_block == VKD3D_BLOCK_LOOP) + return &compiler->control_flow_info[depth]; + } + + return NULL; +} + static struct vkd3d_control_flow_info *vkd3d_dxbc_compiler_find_innermost_breakable_cf_construct( struct vkd3d_dxbc_compiler *compiler) { @@ -5079,8 +5093,6 @@ static void vkd3d_dxbc_compiler_emit_control_flow_instruction(struct vkd3d_dxbc_ return; } - assert(compiler->control_flow_depth); - if (breakable_cf_info->current_block == VKD3D_BLOCK_LOOP) { vkd3d_spirv_build_op_branch(builder, breakable_cf_info->u.loop.merge_block_id); @@ -5102,6 +5114,22 @@ static void vkd3d_dxbc_compiler_emit_control_flow_instruction(struct vkd3d_dxbc_ vkd3d_dxbc_compiler_emit_breakc(compiler, instruction, cf_info->u.loop.merge_block_id); break; + case VKD3DSIH_CONTINUE: + { + struct vkd3d_control_flow_info *loop_cf_info; + + if (!(loop_cf_info = vkd3d_dxbc_compiler_find_innermost_loop(compiler))) + { + ERR("Invalid 'continue' instruction outside loop.\n"); + return; + } + + vkd3d_spirv_build_op_branch(builder, loop_cf_info->u.loop.continue_block_id); + + cf_info->inside_block = false; + break; + } + case VKD3DSIH_RET: vkd3d_dxbc_compiler_emit_return(compiler, instruction); @@ -6278,6 +6306,7 @@ void vkd3d_dxbc_compiler_handle_instruction(struct vkd3d_dxbc_compiler *compiler case VKD3DSIH_BREAK: case VKD3DSIH_BREAKP: case VKD3DSIH_CASE: + case VKD3DSIH_CONTINUE: case VKD3DSIH_DEFAULT: case VKD3DSIH_ELSE: case VKD3DSIH_ENDIF: -- 2.16.4

2 1

[PATCH vkd3d 2/8] vkd3d-shader: Translate ineg instructions.
by Józef Kucia 24 Sep '18

24 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d-shader/spirv.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 6fabeb240a0e..d19d89990d5c 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -4186,6 +4186,7 @@ static SpvOp vkd3d_dxbc_compiler_map_alu_instruction(const struct vkd3d_shader_i {VKD3DSIH_FTOI, SpvOpConvertFToS}, {VKD3DSIH_FTOU, SpvOpConvertFToU}, {VKD3DSIH_IADD, SpvOpIAdd}, + {VKD3DSIH_INEG, SpvOpSNegate}, {VKD3DSIH_ISHL, SpvOpShiftLeftLogical}, {VKD3DSIH_ISHR, SpvOpShiftRightArithmetic}, {VKD3DSIH_ITOF, SpvOpConvertSToF}, @@ -6198,6 +6199,7 @@ void vkd3d_dxbc_compiler_handle_instruction(struct vkd3d_dxbc_compiler *compiler case VKD3DSIH_FTOI: case VKD3DSIH_FTOU: case VKD3DSIH_IADD: + case VKD3DSIH_INEG: case VKD3DSIH_ISHL: case VKD3DSIH_ISHR: case VKD3DSIH_ITOF: -- 2.16.4

2 1

[PATCH vkd3d 1/8] vkd3d-shader: Promote immediate scalar constants to vectors.
by Józef Kucia 24 Sep '18

24 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d-shader/spirv.c | 4 ++-- tests/d3d12.c | 23 +++++++++++++++++++++++ 2 files changed, 25 insertions(+), 2 deletions(-) diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 964bc49b3179..6fabeb240a0e 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -2537,8 +2537,8 @@ static uint32_t vkd3d_dxbc_compiler_emit_load_constant(struct vkd3d_dxbc_compile if (reg->immconst_type == VKD3D_IMMCONST_SCALAR) { - assert(component_count == 1); - values[0] = *reg->u.immconst_uint; + for (i = 0; i < component_count; ++i) + values[i] = *reg->u.immconst_uint; } else { diff --git a/tests/d3d12.c b/tests/d3d12.c index 808562e86127..9bb6861f7757 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -6136,6 +6136,24 @@ static void test_shader_instructions(void) 0x00000001, 0x0100003e, }; static const D3D12_SHADER_BYTECODE ps_ishl = {ps_ishl_code, sizeof(ps_ishl_code)}; + static const DWORD ps_ishl_const_code[] = + { +#if 0 + uint4 src; + + void main(out uint4 dst : SV_Target) + { + dst = src << 2; + } +#endif + 0x43425844, 0x5b749bf4, 0xe24de3dc, 0xbbd75bc9, 0xc6fc9eca, 0x00000001, 0x000000c0, 0x00000003, + 0x0000002c, 0x0000003c, 0x00000070, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, + 0x0000002c, 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000000, 0x00000001, 0x00000000, + 0x0000000f, 0x545f5653, 0x65677261, 0xabab0074, 0x52444853, 0x00000048, 0x00000040, 0x00000012, + 0x04000059, 0x00208e46, 0x00000000, 0x00000001, 0x03000065, 0x001020f2, 0x00000000, 0x08000029, + 0x001020f2, 0x00000000, 0x00208e46, 0x00000000, 0x00000000, 0x00004001, 0x00000002, 0x0100003e, + }; + static const D3D12_SHADER_BYTECODE ps_ishl_const = {ps_ishl_const_code, sizeof(ps_ishl_const_code)}; static const DWORD ps_not_code[] = { #if 0 @@ -6956,6 +6974,11 @@ static void test_shader_instructions(void) {&ps_ishl, {{{0x00000001, 0x00000001, 0x00000001, 0x800feac1}, { 31, 7, 15, 11}}}, {{0x80000000, 0x00000080, 0x00008000, 0x7f560800}}}, + {&ps_ishl_const, {{{0x00000000, 0x00000000, 0x00000000, 0x00000000}}}, + {{0x00000000, 0x00000000, 0x00000000, 0x00000000}}}, + {&ps_ishl_const, {{{0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}}}, + {{0xfffffffc, 0xfffffffc, 0xfffffffc, 0xfffffffc}}}, + {&ps_not, {{{0x00000000, 0xffffffff}}}, {{0xffffffff, 0x00000000, 0x00000000, 0xffffffff}}}, {&ps_not, {{{0xf0f0f0f0, 0x0f0f0f0f}}}, {{0x0f0f0f0f, 0xf0f0f0f0, 0xf0f0f0f0, 0x0f0f0f0f}}}, -- 2.16.4

2 1

[PATCH v3 1/5] shell32/autocomplete: Don't autocomplete at all on most control characters
by Gabriel Ivăncescu 24 Sep '18

24 Sep '18

Most control characters sent via some CTRL+key combination should not autocomplete at all. ^C is one example, where just copying some text should not show the auto-suggestion box (if not visible). ^V is another example, where it is already handled in WM_PASTE, so it has to be a no-op here, else auto-append from WM_PASTE would complete the text and then the ^V autocompletion would remove every other suggestion in the listbox. Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- v3: Use iscntrlW dlls/shell32/autocomplete.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/dlls/shell32/autocomplete.c b/dlls/shell32/autocomplete.c index ef835b9..048a47f 100644 --- a/dlls/shell32/autocomplete.c +++ b/dlls/shell32/autocomplete.c @@ -359,6 +359,10 @@ static LRESULT APIENTRY ACEditSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, return ACEditSubclassProc_KeyDown(This, hwnd, uMsg, wParam, lParam); case WM_CHAR: case WM_UNICHAR: + /* Don't autocomplete at all on most control characters */ + if (iscntrlW(wParam) && !(wParam >= '\b' && wParam <= '\r')) + break; + ret = CallWindowProcW(This->wpOrigEditProc, hwnd, uMsg, wParam, lParam); autocomplete_text(This, hwnd, (This->options & ACO_AUTOAPPEND) && wParam >= ' ' ? autoappend_flag_yes : autoappend_flag_no); -- 1.9.1

3 11

[PATCH] testbot: Fix the detection and reporting of timed out Wine tests.
by Francois Gouget 24 Sep '18

24 Sep '18

Modify ParseWineTestReport() to report the number of test units and timeouts found in the report and remove the IsSuite parameter. This allows the caller to check whether the report has the expected number of test units, and to better decide whether the test as a whole timed out. The policy is to now only consider it to have timed out if all the test units timed out, which would typically only happen when running a single test. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- testbot/bin/WineRunTask.pl | 6 +++--- testbot/bin/WineRunWineTest.pl | 6 +++--- testbot/lib/WineTestBot/LogUtils.pm | 16 +++++++++------- 3 files changed, 15 insertions(+), 13 deletions(-) diff --git a/testbot/bin/WineRunTask.pl b/testbot/bin/WineRunTask.pl index 5ff3fc4a5..077426b23 100755 --- a/testbot/bin/WineRunTask.pl +++ b/testbot/bin/WineRunTask.pl @@ -523,13 +523,13 @@ if (!defined $TA->Wait($Pid, $Timeout, $Keepalive)) } } -my $TimedOut; Debug(Elapsed($Start), " Retrieving the report file to '$RptFileName'\n"); if ($TA->GetFile($RptFileName, "$TaskDir/$RptFileName")) { chmod 0664, "$TaskDir/$RptFileName"; - (my $LogFailures, my $LogErrors, $TimedOut) = ParseWineTestReport("$TaskDir/$RptFileName", $IsWineTest, $Step->Type eq "suite", $TaskTimedOut); + my ($TestUnitCount, $TimeoutCount, $LogFailures, $LogErrors) = ParseWineTestReport("$TaskDir/$RptFileName", $IsWineTest, $TaskTimedOut); + $TaskTimedOut = 1 if ($TestUnitCount == $TimeoutCount); if (!defined $LogFailures and @$LogErrors == 1) { # Could not open the file @@ -563,4 +563,4 @@ FatalTAError(undef, $TAError, $PossibleCrash) if (defined $TAError); # Wrap up # -WrapUpAndExit($NewStatus, $TaskFailures, undef, $TaskTimedOut || $TimedOut); +WrapUpAndExit($NewStatus, $TaskFailures, undef, $TaskTimedOut); diff --git a/testbot/bin/WineRunWineTest.pl b/testbot/bin/WineRunWineTest.pl index e3b8b17ed..90e3403f7 100755 --- a/testbot/bin/WineRunWineTest.pl +++ b/testbot/bin/WineRunWineTest.pl @@ -534,7 +534,6 @@ elsif (!defined $TAError) # Grab the test logs if any # -my $TimedOut; if ($Step->Type ne "build") { my $BuildList = $Task->CmdLineArg; @@ -547,7 +546,8 @@ if ($Step->Type ne "build") { chmod 0664, "$TaskDir/$RptFileName"; - (my $LogFailures, my $LogErrors, $TimedOut) = ParseWineTestReport("$TaskDir/$RptFileName", 1, $Step->Type eq "suite", $TaskTimedOut); + my ($TestUnitCount, $TimeoutCount, $LogFailures, $LogErrors) = ParseWineTestReport("$TaskDir/$RptFileName", 1, $TaskTimedOut); + $TaskTimedOut = 1 if ($TestUnitCount == $TimeoutCount); if (!defined $LogFailures and @$LogErrors == 1) { # Could not open the file @@ -595,4 +595,4 @@ FatalTAError(undef, $TAError, $PossibleCrash) if (defined $TAError); # Wrap up # -WrapUpAndExit($NewStatus, $TaskFailures, undef, $TaskTimedOut || $TimedOut); +WrapUpAndExit($NewStatus, $TaskFailures, undef, $TaskTimedOut); diff --git a/testbot/lib/WineTestBot/LogUtils.pm b/testbot/lib/WineTestBot/LogUtils.pm index b0b804046..17d44a44c 100644 --- a/testbot/lib/WineTestBot/LogUtils.pm +++ b/testbot/lib/WineTestBot/LogUtils.pm @@ -277,23 +277,23 @@ a list of extra errors, and whether the test timed out. =back =cut -sub ParseWineTestReport($$$$) +sub ParseWineTestReport($$$) { - my ($FileName, $IsWineTest, $IsSuite, $TaskTimedOut) = @_; + my ($FileName, $IsWineTest, $TaskTimedOut) = @_; my $LogFile; if (!open($LogFile, "<", $FileName)) { my $BaseName = basename($FileName); - return (undef, ["Unable to open '$BaseName' for reading: $!"], undef); + return (undef, undef, undef, ["Unable to open '$BaseName' for reading: $!"]); } my $Parser = { IsWineTest => $IsWineTest, - IsSuite => $IsSuite, TaskTimedOut => $TaskTimedOut, - TimedOut => undef, + TestUnitCount => 0, + TimeoutCount => 0, Failures => undef, Errors => [], }; @@ -309,6 +309,7 @@ sub ParseWineTestReport($$$$) # Close the previous test unit _CloseTestUnit($Parser, $Cur, 0) if ($Cur->{Dll} ne ""); $Cur = _NewCurrentUnit($Dll, $Unit); + $Parser->{TestUnitCount}++; # Recognize skipped messages in case we need to skip tests in the VMs $Cur->{Rc} = 0 if ($Type eq "skipped"); @@ -414,7 +415,7 @@ sub ParseWineTestReport($$$$) # so record the failure but don't add an error message. $Parser->{Failures}++; $Cur->{IsBroken} = 1; - $Parser->{TimedOut} = $Parser->{IsSuite}; + $Parser->{TimeoutCount}++; } elsif ((!$Pid and !%{$Cur->{Pids}}) or ($Pid and !$Cur->{Pids}->{$Pid} and !$Cur->{Pids}->{0})) @@ -445,7 +446,8 @@ sub ParseWineTestReport($$$$) _CloseTestUnit($Parser, $Cur, 1); close($LogFile); - return ($Parser->{Failures}, $Parser->{Errors}, $Parser->{TimedOut}); + return ($Parser->{TestUnitCount}, $Parser->{TimeoutCount}, + $Parser->{Failures}, $Parser->{Errors}); } -- 2.18.0

1 0

[PATCH] testbot: Fix patchset handling in GetPatchImpacts().
by Francois Gouget 24 Sep '18

24 Sep '18

Only the last part must be taken into account to determine if a rebuild or testing is needed. But they are needed, the previous parts must be taken into account for the rebuild, including the Autoconf and MakeMakefile fields. This also means the scope of the rebuild may be different from that of the tests (we may need a full rebuild to run a single test). So introduce RebuildRoot and RebuildModules which are similar to PatchedRoot and PatchedModules but also take into account patches from previous parts. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- testbot/lib/WineTestBot/PatchUtils.pm | 44 +++++++++++++++------------ 1 file changed, 25 insertions(+), 19 deletions(-) diff --git a/testbot/lib/WineTestBot/PatchUtils.pm b/testbot/lib/WineTestBot/PatchUtils.pm index 2bac7be46..b7307e527 100644 --- a/testbot/lib/WineTestBot/PatchUtils.pm +++ b/testbot/lib/WineTestBot/PatchUtils.pm @@ -283,24 +283,12 @@ sub GetPatchImpacts($;$) if ($PastImpacts) { - if ($PastImpacts->{PatchedRoot} or $PastImpacts->{PatchedModules} or - $PastImpacts->{PatchedTests}) - { - # Update the list of Wine files so we correctly recognize patchset parts - # that modify new Wine files. - my $WineFiles = $PastImpacts->{WineFiles} || $_WineFiles; - map { $Impacts->{WineFiles}->{$_} = 1 } keys %{$WineFiles}; - map { $Impacts->{WineFiles}->{$_} = 1 } keys %{$PastImpacts->{NewFiles}}; - map { delete $Impacts->{WineFiles}->{$_} } keys %{$PastImpacts->{DeletedFiles}}; - # Modules impacted by previous parts of a patchset still need to be - # rebuilt. - $Impacts->{BuildModules} = { %{$PastImpacts->{BuildModules}} }; - } - else - { - $Impacts->{NewFiles} = $PastImpacts->{NewFiles}; - $Impacts->{DeletedFiles} = $PastImpacts->{DeletedFiles}; - } + # Update the list of Wine files so we correctly recognize patchset parts + # that modify new Wine files. + my $WineFiles = $PastImpacts->{WineFiles} || $_WineFiles; + map { $Impacts->{WineFiles}->{$_} = 1 } keys %{$WineFiles}; + map { $Impacts->{WineFiles}->{$_} = 1 } keys %{$PastImpacts->{NewFiles}}; + map { delete $Impacts->{WineFiles}->{$_} } keys %{$PastImpacts->{DeletedFiles}}; foreach my $PastInfo (values %{$PastImpacts->{Tests}}) { @@ -403,6 +391,24 @@ sub GetPatchImpacts($;$) $Impacts->{TestUnitCount} += $TestInfo->{UnitCount}; } + if ($Impacts->{PatchedRoot} or $Impacts->{PatchedModules} or + $Impacts->{PatchedTests}) + { + # Any patched area will need to be rebuilt... + $Impacts->{RebuildRoot} = $Impacts->{PatchedRoot}; + $Impacts->{RebuildModules} = $Impacts->{PatchedModules}; + + # ... even if the patch was in previous parts + if ($PastImpacts) + { + $Impacts->{Autoconf} ||= $PastImpacts->{Autoconf}; + $Impacts->{MakeMakefiles} ||= $PastImpacts->{MakeMakefiles}; + $Impacts->{RebuildRoot} ||= $PastImpacts->{PatchedRoot}; + $Impacts->{RebuildModules} ||= $PastImpacts->{PatchedModules}; + map { $Impacts->{BuildModules}->{$_} = 1 } keys %{$PastImpacts->{BuildModules}}; + } + } + return $Impacts; } @@ -419,7 +425,7 @@ sub GetBuildTimeout($$) map {$_ =~ /^exe/ ? $ExeCount++ : $WineCount++ } keys %$Builds; # Set $ModuleCount to 0 if a full rebuild is needed - my $ModuleCount = (!$Impacts or $Impacts->{PatchedRoot}) ? 0 : + my $ModuleCount = (!$Impacts or $Impacts->{RebuildRoot}) ? 0 : scalar(keys %{$Impacts->{BuildModules}}); my ($ExeTimeout, $WineTimeout) = (0, 0); -- 2.18.0

1 0

[PATCH] testbot: Increase the full rebuild timeouts.
by Francois Gouget 24 Sep '18

24 Sep '18

The increased timeouts can be needed if the computer is otherwise busy (which should not be happening on the official TestBot unless the administrator is doing some maintenance on the side). The new timeouts should provide at least a 50% margin, thus also leaving some room for Wine to grow. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- There was a timeout on the TestBot once during a Wine update. The same day I also got a timeout on my box (but that's less surprising since it may have been busy with other things at the time). Hopefully the timeout increases will prevent a reoccurrence. testbot/lib/WineTestBot/Config.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/testbot/lib/WineTestBot/Config.pm b/testbot/lib/WineTestBot/Config.pm index a83085d44..157617780 100644 --- a/testbot/lib/WineTestBot/Config.pm +++ b/testbot/lib/WineTestBot/Config.pm @@ -95,13 +95,13 @@ $MaxTaskTries = 3; # Exe build timeouts (in seconds) # - For a full build $ExeBuildNativeTimeout = 60; -$ExeBuildTestTimeout = 2 * 60; +$ExeBuildTestTimeout = 4 * 60; # - For a single module $ExeModuleTimeout = 30; # Wine build timeouts (in seconds) # - For a full build -$WineBuildTimeout = 20 * 60; +$WineBuildTimeout = 25 * 60; # - For a single module $WineModuleTimeout = 60; -- 2.18.0

1 0

[PATCH] testbot: Improve error checking when combining patchset parts.
by Francois Gouget 24 Sep '18

24 Sep '18

Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- testbot/lib/WineTestBot/PendingPatchSets.pm | 23 ++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-) diff --git a/testbot/lib/WineTestBot/PendingPatchSets.pm b/testbot/lib/WineTestBot/PendingPatchSets.pm index 4ef7a663a..3ac8c5350 100644 --- a/testbot/lib/WineTestBot/PendingPatchSets.pm +++ b/testbot/lib/WineTestBot/PendingPatchSets.pm @@ -106,20 +106,33 @@ sub SubmitSubset($$$) my ($CombinedFile, $CombinedFileName) = OpenNewFile("$DataDir/staging", "_patch"); return "Could not create a combined patch file: $!" if (!$CombinedFile); - my $Parts = $self->Parts; + my $ErrMessage; for (my $PartNo = 1; $PartNo <= $MaxPart; $PartNo++) { - my $Part = $Parts->GetItem($PartNo); - if (defined $Part and - open(my $PartFile, "<" , "$DataDir/patches/" . $Part->Patch->Id)) + my $Part = $self->Parts->GetItem($PartNo); + if (!defined $Part) + { + $ErrMessage = "Could not find part $PartNo / $MaxPart"; + last; + } + + if (open(my $PartFile, "<" , "$DataDir/patches/" . $Part->Patch->Id)) { print $CombinedFile $_ for (<$PartFile>); close($PartFile); } + else + { + $ErrMessage = "Could not open part $PartNo for reading: $!"; + last; + } } close($CombinedFile); - my $ErrMessage = $FinalPatch->Submit($CombinedFileName, 1); + if (!defined $ErrMessage) + { + $ErrMessage = $FinalPatch->Submit($CombinedFileName, 1); + } unlink($CombinedFileName); return $ErrMessage; -- 2.18.0

1 0

[PATCH] comctl32: Improve hit testing and invalidation for sub items.
by Jim Mussared 24 Sep '18

24 Sep '18

These fixes are for "Vectric Cut2D" which uses listview to show document layers. See referenced bug for more details. The layer list uses clickable subitems for: - toggling visibility of the layer - color swatch (click to edit color) - menu (click to show the right-click menu) (all of these are activated on mouse up) At the moment, the sub items are not clickable in Wine. Additionally, they do not update when the layer changes state. This patch fixes three things: - When hit testing, the sub items's coordinates are relative to the item. So the mouse coordinate (opt) will be outside the bounds of the item (rcBounds), and fail the hit test. Skip this check when not doing a selection hit test (which applies to mouse up). - InvalidateItem only invalidates the region of the primary item. Now also invalidate all sub-items. - InvalidateSubItem calculated the position of the subitem incorrectly (it's offset by the left edge of the main item). Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=44794 Signed-off-by: Jim Mussared <jim.mussared(a)gmail.com> --- dlls/comctl32/listview.c | 41 ++++++++++++++++++++++++---------------- 1 file changed, 25 insertions(+), 16 deletions(-) diff --git a/dlls/comctl32/listview.c b/dlls/comctl32/listview.c index 777b40f2fe..1440581f71 100644 --- a/dlls/comctl32/listview.c +++ b/dlls/comctl32/listview.c @@ -1725,38 +1725,46 @@ static inline BOOL is_redrawing(const LISTVIEW_INFO *infoPtr) static inline void LISTVIEW_InvalidateRect(const LISTVIEW_INFO *infoPtr, const RECT* rect) { - if(!is_redrawing(infoPtr)) return; + if(!is_redrawing(infoPtr)) return; TRACE(" invalidating rect=%s\n", wine_dbgstr_rect(rect)); InvalidateRect(infoPtr->hwndSelf, rect, TRUE); } -static inline void LISTVIEW_InvalidateItem(const LISTVIEW_INFO *infoPtr, INT nItem) -{ - RECT rcBox; - - if (!is_redrawing(infoPtr) || nItem < 0 || nItem >= infoPtr->nItemCount) - return; - - LISTVIEW_GetItemBox(infoPtr, nItem, &rcBox); - LISTVIEW_InvalidateRect(infoPtr, &rcBox); -} - static inline void LISTVIEW_InvalidateSubItem(const LISTVIEW_INFO *infoPtr, INT nItem, INT nSubItem) { POINT Origin, Position; RECT rcBox; - - if(!is_redrawing(infoPtr)) return; + + if(!is_redrawing(infoPtr)) return; assert (infoPtr->uView == LV_VIEW_DETAILS); LISTVIEW_GetOrigin(infoPtr, &Origin); LISTVIEW_GetItemOrigin(infoPtr, nItem, &Position); LISTVIEW_GetHeaderRect(infoPtr, nSubItem, &rcBox); rcBox.top = 0; rcBox.bottom = infoPtr->nItemHeight; - OffsetRect(&rcBox, Origin.x + Position.x, Origin.y + Position.y); + OffsetRect(&rcBox, Origin.x, Origin.y + Position.y); LISTVIEW_InvalidateRect(infoPtr, &rcBox); } +static inline void LISTVIEW_InvalidateItem(const LISTVIEW_INFO *infoPtr, INT nItem) +{ + RECT rcBox; + + if (!is_redrawing(infoPtr) || nItem < 0 || nItem >= infoPtr->nItemCount) + return; + + LISTVIEW_GetItemBox(infoPtr, nItem, &rcBox); + LISTVIEW_InvalidateRect(infoPtr, &rcBox); + + /* Additionally invalidate all other sub-items. + The first sub-item is handled by GetItemBox above. */ + if (infoPtr->uView == LV_VIEW_DETAILS) { + INT nSubItem; + for (nSubItem = 1; nSubItem < DPA_GetPtrCount(infoPtr->hdpaColumns); nSubItem++) + LISTVIEW_InvalidateSubItem(infoPtr, nItem, nSubItem); + } +} + static inline void LISTVIEW_InvalidateList(const LISTVIEW_INFO *infoPtr) { LISTVIEW_InvalidateRect(infoPtr, NULL); @@ -7741,8 +7749,9 @@ static INT LISTVIEW_HitTest(const LISTVIEW_INFO *infoPtr, LPLVHITTESTINFO lpht, UnionRect(&rcBounds, &rcIcon, &rcLabel); UnionRect(&rcBounds, &rcBounds, &rcState); } + TRACE("rcBounds=%s\n", wine_dbgstr_rect(&rcBounds)); - if (!PtInRect(&rcBounds, opt)) return -1; + if (select && !PtInRect(&rcBounds, opt)) return -1; /* That's a special case - row rectangle is used as item rectangle and returned flags contain all item parts. */ -- 2.19.0

4 3

[PATCH] comctl32/listview: Fix subitem invalidation.
by Nikolay Sivov 24 Sep '18

24 Sep '18

From: Jim Mussared <jim.mussared(a)gmail.com> It's wrong to offset by item position, columns could be reordered. Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/comctl32/listview.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/comctl32/listview.c b/dlls/comctl32/listview.c index 777b40f2fe..95d619af75 100644 --- a/dlls/comctl32/listview.c +++ b/dlls/comctl32/listview.c @@ -1753,7 +1753,7 @@ static inline void LISTVIEW_InvalidateSubItem(const LISTVIEW_INFO *infoPtr, INT LISTVIEW_GetHeaderRect(infoPtr, nSubItem, &rcBox); rcBox.top = 0; rcBox.bottom = infoPtr->nItemHeight; - OffsetRect(&rcBox, Origin.x + Position.x, Origin.y + Position.y); + OffsetRect(&rcBox, Origin.x, Origin.y + Position.y); LISTVIEW_InvalidateRect(infoPtr, &rcBox); } -- 2.19.0

2 1

[PATCH 4/4] comctl32/pager: Support tree view notification conversion.
by Zhiyi Zhang 24 Sep '18

24 Sep '18

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/comctl32/pager.c | 73 +++++++++++++++++++++++++++++ dlls/comctl32/tests/pager.c | 91 ++++++++++++++++++++++++++++++++++++- 2 files changed, 163 insertions(+), 1 deletion(-) diff --git a/dlls/comctl32/pager.c b/dlls/comctl32/pager.c index 343c330969..4763ed5640 100644 --- a/dlls/comctl32/pager.c +++ b/dlls/comctl32/pager.c @@ -1074,6 +1074,19 @@ static UINT PAGER_GetAnsiNtfCode(UINT code) case TBN_GETINFOTIPW: return TBN_GETINFOTIPA; /* Tooltip */ case TTN_GETDISPINFOW: return TTN_GETDISPINFOA; + /* Tree View */ + case TVN_BEGINDRAGW: return TVN_BEGINDRAGA; + case TVN_BEGINLABELEDITW: return TVN_BEGINLABELEDITA; + case TVN_BEGINRDRAGW: return TVN_BEGINRDRAGA; + case TVN_DELETEITEMW: return TVN_DELETEITEMA; + case TVN_ENDLABELEDITW: return TVN_ENDLABELEDITA; + case TVN_GETDISPINFOW: return TVN_GETDISPINFOA; + case TVN_GETINFOTIPW: return TVN_GETINFOTIPA; + case TVN_ITEMEXPANDEDW: return TVN_ITEMEXPANDEDA; + case TVN_ITEMEXPANDINGW: return TVN_ITEMEXPANDINGA; + case TVN_SELCHANGEDW: return TVN_SELCHANGEDA; + case TVN_SELCHANGINGW: return TVN_SELCHANGINGA; + case TVN_SETDISPINFOW: return TVN_SETDISPINFOA; } return code; } @@ -1375,6 +1388,66 @@ static LRESULT PAGER_Notify(PAGER_INFO *infoPtr, NMHDR *hdr) return ret; } + /* Tree View */ + case TVN_BEGINDRAGW: + case TVN_BEGINRDRAGW: + case TVN_ITEMEXPANDEDW: + case TVN_ITEMEXPANDINGW: + { + NMTREEVIEWW *nmtv = (NMTREEVIEWW *)hdr; + return PAGER_SendConvertedNotify(infoPtr, hdr, &nmtv->itemNew.mask, TVIF_TEXT, &nmtv->itemNew.pszText, NULL, + CONVERT_SEND); + } + case TVN_DELETEITEMW: + { + NMTREEVIEWW *nmtv = (NMTREEVIEWW *)hdr; + return PAGER_SendConvertedNotify(infoPtr, hdr, &nmtv->itemOld.mask, TVIF_TEXT, &nmtv->itemOld.pszText, NULL, + CONVERT_SEND); + } + case TVN_BEGINLABELEDITW: + case TVN_ENDLABELEDITW: + { + NMTVDISPINFOW *nmtvdi = (NMTVDISPINFOW *)hdr; + return PAGER_SendConvertedNotify(infoPtr, hdr, &nmtvdi->item.mask, TVIF_TEXT, &nmtvdi->item.pszText, + &nmtvdi->item.cchTextMax, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE); + } + case TVN_SELCHANGINGW: + case TVN_SELCHANGEDW: + { + NMTREEVIEWW *nmtv = (NMTREEVIEWW *)hdr; + WCHAR *oldItemOldText = NULL; + WCHAR *oldItemNewText = NULL; + + hdr->code = PAGER_GetAnsiNtfCode(hdr->code); + + if (!((nmtv->itemNew.mask | nmtv->itemOld.mask) & TVIF_TEXT)) + return SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, hdr->idFrom, (LPARAM)hdr); + + if (nmtv->itemOld.mask & TVIF_TEXT) oldItemOldText = PAGER_ConvertText(&nmtv->itemOld.pszText); + if (nmtv->itemNew.mask & TVIF_TEXT) oldItemNewText = PAGER_ConvertText(&nmtv->itemNew.pszText); + + ret = SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, hdr->idFrom, (LPARAM)hdr); + PAGER_RestoreText(&nmtv->itemOld.pszText, oldItemOldText); + PAGER_RestoreText(&nmtv->itemNew.pszText, oldItemNewText); + return ret; + } + case TVN_GETDISPINFOW: + { + NMTVDISPINFOW *nmtvdi = (NMTVDISPINFOW *)hdr; + return PAGER_SendConvertedNotify(infoPtr, hdr, &nmtvdi->item.mask, TVIF_TEXT, &nmtvdi->item.pszText, + &nmtvdi->item.cchTextMax, ZERO_SEND | CONVERT_RECEIVE); + } + case TVN_SETDISPINFOW: + { + NMTVDISPINFOW *nmtvdi = (NMTVDISPINFOW *)hdr; + return PAGER_SendConvertedNotify(infoPtr, hdr, &nmtvdi->item.mask, TVIF_TEXT, &nmtvdi->item.pszText, + &nmtvdi->item.cchTextMax, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE); + } + case TVN_GETINFOTIPW: + { + NMTVGETINFOTIPW *nmtvgit = (NMTVGETINFOTIPW *)hdr; + return PAGER_SendConvertedNotify(infoPtr, hdr, NULL, 0, &nmtvgit->pszText, &nmtvgit->cchTextMax, CONVERT_RECEIVE); + } } /* Other notifications, no need to convert */ return SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, hdr->idFrom, (LPARAM)hdr); diff --git a/dlls/comctl32/tests/pager.c b/dlls/comctl32/tests/pager.c index 05fbc55fa2..17fc4bdf81 100644 --- a/dlls/comctl32/tests/pager.c +++ b/dlls/comctl32/tests/pager.c @@ -72,6 +72,12 @@ enum test_conversion_flags ZERO_SEND = 0x80 }; +enum handler_ids +{ + TVITEM_NEW_HANDLER, + TVITEM_OLD_HANDLER +}; + static struct notify_test_info { UINT unicode; @@ -82,6 +88,7 @@ static struct notify_test_info BOOL received; UINT test_id; UINT sub_test_id; + UINT handler_id; /* Text field conversion test behavior flag */ DWORD flags; } notify_test_info; @@ -123,6 +130,7 @@ struct generic_text_helper_para UINT code_unicode; UINT code_ansi; DWORD flags; + UINT handler_id; }; static const struct notify_test_send test_convert_send_data[] = @@ -850,6 +858,39 @@ static LRESULT WINAPI test_notify_proc(HWND hwnd, UINT message, WPARAM wParam, L notify_tooltip_handler((NMTTDISPINFOA *)hdr); break; } + /* Tree View */ + case TVN_BEGINLABELEDITA: + case TVN_ENDLABELEDITA: + case TVN_GETDISPINFOA: + case TVN_SETDISPINFOA: + { + NMTVDISPINFOA *nmtvdi = (NMTVDISPINFOA *)hdr; + notify_generic_text_handler(&nmtvdi->item.pszText, &nmtvdi->item.cchTextMax); + break; + } + case TVN_GETINFOTIPA: + { + NMTVGETINFOTIPA *nmtvgit = (NMTVGETINFOTIPA *)hdr; + notify_generic_text_handler(&nmtvgit->pszText, &nmtvgit->cchTextMax); + break; + } + case TVN_SINGLEEXPAND: + case TVN_BEGINDRAGA: + case TVN_BEGINRDRAGA: + case TVN_ITEMEXPANDEDA: + case TVN_ITEMEXPANDINGA: + case TVN_DELETEITEMA: + case TVN_SELCHANGINGA: + case TVN_SELCHANGEDA: + { + NMTREEVIEWA *nmtv = (NMTREEVIEWA *)hdr; + if (notify_test_info.handler_id == TVITEM_NEW_HANDLER) + notify_generic_text_handler((CHAR **)&nmtv->itemNew.pszText, &nmtv->itemNew.cchTextMax); + else + notify_generic_text_handler((CHAR **)&nmtv->itemOld.pszText, &nmtv->itemOld.cchTextMax); + break; + } + default: ok(0, "Unexpected message 0x%08x\n", hdr->code); } @@ -904,6 +945,7 @@ static void test_notify_generic_text_helper(HWND pager, const struct generic_tex INT i; notify_test_info.flags = para->flags; + notify_test_info.handler_id = para->handler_id; if (para->flags & (CONVERT_SEND | DONT_CONVERT_SEND)) { @@ -1141,6 +1183,10 @@ static void test_wm_notify(void) static NMTOOLBARW nmtb; static NMTBDISPINFOW nmtbdi; static NMTBGETINFOTIPW nmtbgit; + /* Tree View */ + static NMTVDISPINFOW nmtvdi; + static NMTVGETINFOTIPW nmtvgit; + static NMTREEVIEWW nmtv; static const struct generic_text_helper_para paras[] = { /* Combo Box Ex */ @@ -1185,7 +1231,50 @@ static void test_wm_notify(void) {&nmtb, sizeof(nmtb), NULL, 0, &nmtb.pszText, &nmtb.cchText, TBN_GETBUTTONINFOW, TBN_GETBUTTONINFOA, SEND_EMPTY_IF_NULL | CONVERT_SEND | CONVERT_RECEIVE}, {&nmtbgit, sizeof(nmtbgit), NULL, 0, &nmtbgit.pszText, &nmtbgit.cchTextMax, TBN_GETINFOTIPW, TBN_GETINFOTIPA, - DONT_CONVERT_SEND | CONVERT_RECEIVE} + DONT_CONVERT_SEND | CONVERT_RECEIVE}, + /* Tree View */ + {&nmtvdi, sizeof(nmtvdi), &nmtvdi.item.mask, TVIF_TEXT, &nmtvdi.item.pszText, &nmtvdi.item.cchTextMax, + TVN_BEGINLABELEDITW, TVN_BEGINLABELEDITA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE}, + {&nmtvdi, sizeof(nmtvdi), &nmtvdi.item.mask, TVIF_TEXT, &nmtvdi.item.pszText, &nmtvdi.item.cchTextMax, + TVN_ENDLABELEDITW, TVN_ENDLABELEDITA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE}, + {&nmtvdi, sizeof(nmtvdi), &nmtvdi.item.mask, TVIF_TEXT, &nmtvdi.item.pszText, &nmtvdi.item.cchTextMax, + TVN_GETDISPINFOW, TVN_GETDISPINFOA, ZERO_SEND | DONT_CONVERT_SEND| CONVERT_RECEIVE}, + {&nmtvdi, sizeof(nmtvdi), &nmtvdi.item.mask, TVIF_TEXT, &nmtvdi.item.pszText, &nmtvdi.item.cchTextMax, + TVN_SETDISPINFOW, TVN_SETDISPINFOA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE}, + {&nmtvgit, sizeof(nmtvgit), NULL, 0, &nmtvgit.pszText, &nmtvgit.cchTextMax, TVN_GETINFOTIPW, TVN_GETINFOTIPA, + DONT_CONVERT_SEND | CONVERT_RECEIVE}, + {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax, + TVN_SINGLEEXPAND, TVN_SINGLEEXPAND, DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE, TVITEM_NEW_HANDLER}, + {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax, + TVN_SINGLEEXPAND, TVN_SINGLEEXPAND, DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE, TVITEM_OLD_HANDLER}, + {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax, + TVN_BEGINDRAGW, TVN_BEGINDRAGA, CONVERT_SEND, TVITEM_NEW_HANDLER}, + {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax, + TVN_BEGINDRAGW, TVN_BEGINDRAGA, DONT_CONVERT_SEND, TVITEM_OLD_HANDLER}, + {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax, + TVN_BEGINRDRAGW, TVN_BEGINRDRAGA, CONVERT_SEND, TVITEM_NEW_HANDLER}, + {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax, + TVN_BEGINRDRAGW, TVN_BEGINRDRAGA, DONT_CONVERT_SEND, TVITEM_OLD_HANDLER}, + {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax, + TVN_ITEMEXPANDEDW, TVN_ITEMEXPANDEDA, CONVERT_SEND, TVITEM_NEW_HANDLER}, + {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax, + TVN_ITEMEXPANDEDW, TVN_ITEMEXPANDEDA, DONT_CONVERT_SEND, TVITEM_OLD_HANDLER}, + {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax, + TVN_ITEMEXPANDINGW, TVN_ITEMEXPANDINGA, CONVERT_SEND, TVITEM_NEW_HANDLER}, + {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax, + TVN_ITEMEXPANDINGW, TVN_ITEMEXPANDINGA, DONT_CONVERT_SEND, TVITEM_OLD_HANDLER}, + {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax, + TVN_DELETEITEMW, TVN_DELETEITEMA, DONT_CONVERT_SEND, TVITEM_NEW_HANDLER}, + {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax, + TVN_DELETEITEMW, TVN_DELETEITEMA, CONVERT_SEND, TVITEM_OLD_HANDLER}, + {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax, + TVN_SELCHANGINGW, TVN_SELCHANGINGA, CONVERT_SEND, TVITEM_NEW_HANDLER}, + {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax, + TVN_SELCHANGINGW, TVN_SELCHANGINGA, CONVERT_SEND, TVITEM_OLD_HANDLER}, + {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax, + TVN_SELCHANGEDW, TVN_SELCHANGEDA, CONVERT_SEND, TVITEM_NEW_HANDLER}, + {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax, + TVN_SELCHANGEDW, TVN_SELCHANGEDA, CONVERT_SEND, TVITEM_OLD_HANDLER} }; INT i; -- 2.18.0

1 0

[PATCH 3/4] comctl32/pager: Support list view notification conversion.
by Zhiyi Zhang 24 Sep '18

24 Sep '18

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/comctl32/pager.c | 36 +++++++++++++++++++++++++++++++ dlls/comctl32/tests/pager.c | 42 +++++++++++++++++++++++++++++++++++++ 2 files changed, 78 insertions(+) diff --git a/dlls/comctl32/pager.c b/dlls/comctl32/pager.c index 31c8f5efe6..343c330969 100644 --- a/dlls/comctl32/pager.c +++ b/dlls/comctl32/pager.c @@ -1061,6 +1061,14 @@ static UINT PAGER_GetAnsiNtfCode(UINT code) case HDN_ITEMCLICKW: return HDN_ITEMCLICKA; case HDN_ITEMDBLCLICKW: return HDN_ITEMDBLCLICKA; case HDN_TRACKW: return HDN_TRACKA; + /* List View */ + case LVN_BEGINLABELEDITW: return LVN_BEGINLABELEDITA; + case LVN_ENDLABELEDITW: return LVN_ENDLABELEDITA; + case LVN_GETDISPINFOW: return LVN_GETDISPINFOA; + case LVN_GETINFOTIPW: return LVN_GETINFOTIPA; + case LVN_INCREMENTALSEARCHW: return LVN_INCREMENTALSEARCHA; + case LVN_ODFINDITEMW: return LVN_ODFINDITEMA; + case LVN_SETDISPINFOW: return LVN_SETDISPINFOA; /* Toolbar */ case TBN_GETBUTTONINFOW: return TBN_GETBUTTONINFOA; case TBN_GETINFOTIPW: return TBN_GETINFOTIPA; @@ -1275,6 +1283,34 @@ static LRESULT PAGER_Notify(PAGER_INFO *infoPtr, NMHDR *hdr) return PAGER_SendConvertedNotify(infoPtr, hdr, &nmhddi->mask, HDI_TEXT, &nmhddi->pszText, &nmhddi->cchTextMax, SEND_EMPTY_IF_NULL | CONVERT_SEND | CONVERT_RECEIVE); } + /* List View */ + case LVN_BEGINLABELEDITW: + case LVN_ENDLABELEDITW: + case LVN_SETDISPINFOW: + { + NMLVDISPINFOW *nmlvdi = (NMLVDISPINFOW *)hdr; + return PAGER_SendConvertedNotify(infoPtr, hdr, &nmlvdi->item.mask, LVIF_TEXT, &nmlvdi->item.pszText, + &nmlvdi->item.cchTextMax, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE); + } + case LVN_GETDISPINFOW: + { + NMLVDISPINFOW *nmlvdi = (NMLVDISPINFOW *)hdr; + return PAGER_SendConvertedNotify(infoPtr, hdr, &nmlvdi->item.mask, LVIF_TEXT, &nmlvdi->item.pszText, + &nmlvdi->item.cchTextMax, CONVERT_RECEIVE); + } + case LVN_GETINFOTIPW: + { + NMLVGETINFOTIPW *nmlvgit = (NMLVGETINFOTIPW *)hdr; + return PAGER_SendConvertedNotify(infoPtr, hdr, NULL, 0, &nmlvgit->pszText, &nmlvgit->cchTextMax, + CONVERT_SEND | CONVERT_RECEIVE); + } + case LVN_INCREMENTALSEARCHW: + case LVN_ODFINDITEMW: + { + NMLVFINDITEMW *nmlvfi = (NMLVFINDITEMW *)hdr; + return PAGER_SendConvertedNotify(infoPtr, hdr, &nmlvfi->lvfi.flags, LVFI_STRING | LVFI_SUBSTRING, + (WCHAR **)&nmlvfi->lvfi.psz, NULL, CONVERT_SEND); + } /* Toolbar */ case TBN_GETBUTTONINFOW: { diff --git a/dlls/comctl32/tests/pager.c b/dlls/comctl32/tests/pager.c index a2a6f9cd37..05fbc55fa2 100644 --- a/dlls/comctl32/tests/pager.c +++ b/dlls/comctl32/tests/pager.c @@ -790,6 +790,29 @@ static LRESULT WINAPI test_notify_proc(HWND hwnd, UINT message, WPARAM wParam, L notify_generic_text_handler(&nmhddi->pszText, &nmhddi->cchTextMax); break; } + /* List View */ + case LVN_BEGINLABELEDITA: + case LVN_ENDLABELEDITA: + case LVN_GETDISPINFOA: + case LVN_SETDISPINFOA: + { + NMLVDISPINFOA *nmlvdi = (NMLVDISPINFOA *)hdr; + notify_generic_text_handler(&nmlvdi->item.pszText, &nmlvdi->item.cchTextMax); + break; + } + case LVN_GETINFOTIPA: + { + NMLVGETINFOTIPA *nmlvgit = (NMLVGETINFOTIPA *)hdr; + notify_generic_text_handler(&nmlvgit->pszText, &nmlvgit->cchTextMax); + break; + } + case LVN_INCREMENTALSEARCHA: + case LVN_ODFINDITEMA: + { + NMLVFINDITEMA *nmlvfi = (NMLVFINDITEMA *)hdr; + notify_generic_text_handler((CHAR **)&nmlvfi->lvfi.psz, NULL); + break; + } /* Toolbar */ case TBN_SAVE: { @@ -1108,6 +1131,10 @@ static void test_wm_notify(void) static NMDATETIMESTRINGW nmdts; /* Header */ static NMHDDISPINFOW nmhddi; + /* List View */ + static NMLVDISPINFOW nmlvdi; + static NMLVGETINFOTIPW nmlvgit; + static NMLVFINDITEMW nmlvfi; /* Tool Bar */ static NMTBRESTORE nmtbr; static NMTBSAVE nmtbs; @@ -1133,6 +1160,21 @@ static void test_wm_notify(void) /* Header */ {&nmhddi, sizeof(nmhddi), &nmhddi.mask, HDI_TEXT, &nmhddi.pszText, &nmhddi.cchTextMax, HDN_GETDISPINFOW, HDN_GETDISPINFOA, SEND_EMPTY_IF_NULL | CONVERT_SEND | CONVERT_RECEIVE}, + /* List View */ + {&nmlvfi, sizeof(nmlvfi), &nmlvfi.lvfi.flags, LVFI_STRING, (WCHAR **)&nmlvfi.lvfi.psz, NULL, + LVN_INCREMENTALSEARCHW, LVN_INCREMENTALSEARCHA, CONVERT_SEND}, + {&nmlvfi, sizeof(nmlvfi), &nmlvfi.lvfi.flags, LVFI_SUBSTRING, (WCHAR **)&nmlvfi.lvfi.psz, NULL, LVN_ODFINDITEMW, + LVN_ODFINDITEMA, CONVERT_SEND}, + {&nmlvdi, sizeof(nmlvdi), &nmlvdi.item.mask, LVIF_TEXT, &nmlvdi.item.pszText, &nmlvdi.item.cchTextMax, + LVN_BEGINLABELEDITW, LVN_BEGINLABELEDITA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE}, + {&nmlvdi, sizeof(nmlvdi), &nmlvdi.item.mask, LVIF_TEXT, &nmlvdi.item.pszText, &nmlvdi.item.cchTextMax, + LVN_ENDLABELEDITW, LVN_ENDLABELEDITA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE}, + {&nmlvdi, sizeof(nmlvdi), &nmlvdi.item.mask, LVIF_TEXT, &nmlvdi.item.pszText, &nmlvdi.item.cchTextMax, + LVN_GETDISPINFOW, LVN_GETDISPINFOA, DONT_CONVERT_SEND | CONVERT_RECEIVE}, + {&nmlvdi, sizeof(nmlvdi), &nmlvdi.item.mask, LVIF_TEXT, &nmlvdi.item.pszText, &nmlvdi.item.cchTextMax, + LVN_SETDISPINFOW, LVN_SETDISPINFOA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE}, + {&nmlvgit, sizeof(nmlvgit), NULL, 0, &nmlvgit.pszText, &nmlvgit.cchTextMax, LVN_GETINFOTIPW, LVN_GETINFOTIPA, + CONVERT_SEND | CONVERT_RECEIVE}, /* Tool Bar */ {&nmtbs, sizeof(nmtbs), NULL, 0, (WCHAR **)&nmtbs.tbButton.iString, NULL, TBN_SAVE, TBN_SAVE, DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE}, -- 2.18.0

1 0

[PATCH] kernel32: Add GetQueuedCompletionStatusEx stub.
by Gijs Vermeulen 23 Sep '18

23 Sep '18

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=43878 Signed-off-by: Gijs Vermeulen <gijsvrm(a)gmail.com> --- .../api-ms-win-core-io-l1-1-0.spec | 2 +- .../api-ms-win-core-io-l1-1-1.spec | 2 +- dlls/kernel32/kernel32.spec | 2 +- dlls/kernel32/sync.c | 12 ++++++++++++ dlls/kernelbase/kernelbase.spec | 2 +- include/winbase.h | 7 +++++++ 6 files changed, 23 insertions(+), 4 deletions(-) diff --git a/dlls/api-ms-win-core-io-l1-1-0/api-ms-win-core-io-l1-1-0.spec b/dlls/api-ms-win-core-io-l1-1-0/api-ms-win-core-io-l1-1-0.spec index f73e427782..44d42d1266 100644 --- a/dlls/api-ms-win-core-io-l1-1-0/api-ms-win-core-io-l1-1-0.spec +++ b/dlls/api-ms-win-core-io-l1-1-0/api-ms-win-core-io-l1-1-0.spec @@ -3,5 +3,5 @@ @ stdcall DeviceIoControl(long long ptr long ptr long ptr ptr) kernel32.DeviceIoControl @ stdcall GetOverlappedResult(long ptr ptr long) kernel32.GetOverlappedResult @ stdcall GetQueuedCompletionStatus(long ptr ptr ptr long) kernel32.GetQueuedCompletionStatus -@ stub GetQueuedCompletionStatusEx +@ stdcall GetQueuedCompletionStatusEx(long ptr long ptr long long) kernel32.GetQueuedCompletionStatusEx @ stdcall PostQueuedCompletionStatus(long long ptr ptr) kernel32.PostQueuedCompletionStatus diff --git a/dlls/api-ms-win-core-io-l1-1-1/api-ms-win-core-io-l1-1-1.spec b/dlls/api-ms-win-core-io-l1-1-1/api-ms-win-core-io-l1-1-1.spec index 73aae1aa9a..d335efaee8 100644 --- a/dlls/api-ms-win-core-io-l1-1-1/api-ms-win-core-io-l1-1-1.spec +++ b/dlls/api-ms-win-core-io-l1-1-1/api-ms-win-core-io-l1-1-1.spec @@ -6,5 +6,5 @@ @ stdcall GetOverlappedResult(long ptr ptr long) kernel32.GetOverlappedResult @ stub GetOverlappedResultEx @ stdcall GetQueuedCompletionStatus(long ptr ptr ptr long) kernel32.GetQueuedCompletionStatus -@ stub GetQueuedCompletionStatusEx +@ stdcall GetQueuedCompletionStatusEx(long ptr long ptr long long) kernel32.GetQueuedCompletionStatusEx @ stdcall PostQueuedCompletionStatus(long long ptr ptr) kernel32.PostQueuedCompletionStatus diff --git a/dlls/kernel32/kernel32.spec b/dlls/kernel32/kernel32.spec index 9db7d98f41..cb9c73aef8 100644 --- a/dlls/kernel32/kernel32.spec +++ b/dlls/kernel32/kernel32.spec @@ -804,7 +804,7 @@ @ stdcall GetProfileStringA(str str str ptr long) @ stdcall GetProfileStringW(wstr wstr wstr ptr long) @ stdcall GetQueuedCompletionStatus(long ptr ptr ptr long) -# @ stub GetQueuedCompletionStatusEx +@ stdcall GetQueuedCompletionStatusEx(long ptr long ptr long long) @ stub -i386 GetSLCallbackTarget @ stub -i386 GetSLCallbackTemplate @ stdcall GetShortPathNameA(str ptr long) diff --git a/dlls/kernel32/sync.c b/dlls/kernel32/sync.c index a855e95117..58ecc09003 100644 --- a/dlls/kernel32/sync.c +++ b/dlls/kernel32/sync.c @@ -2377,6 +2377,18 @@ BOOL WINAPI GetQueuedCompletionStatus( HANDLE CompletionPort, LPDWORD lpNumberOf return FALSE; } +/****************************************************************************** + * GetQueuedCompletionStatusEx (KERNEL32.@) + */ +BOOL WINAPI GetQueuedCompletionStatusEx(HANDLE completion_port, LPOVERLAPPED_ENTRY completion_port_entries, + ULONG count, ULONG *num_entries_removed, DWORD milliseconds, + BOOL alertable) +{ + FIXME("(%p, %p, %d, %p, %d, %d) stub!\n", + completion_port, completion_port_entries, count, num_entries_removed, milliseconds, alertable); + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; +} /****************************************************************************** * PostQueuedCompletionStatus (KERNEL32.@) diff --git a/dlls/kernelbase/kernelbase.spec b/dlls/kernelbase/kernelbase.spec index 29805760da..7d8439fbd6 100644 --- a/dlls/kernelbase/kernelbase.spec +++ b/dlls/kernelbase/kernelbase.spec @@ -645,7 +645,7 @@ # @ stub GetPublisherCacheFolder # @ stub GetPublisherRootFolder @ stdcall GetQueuedCompletionStatus(long ptr ptr ptr long) kernel32.GetQueuedCompletionStatus -@ stub GetQueuedCompletionStatusEx +@ stdcall GetQueuedCompletionStatusEx(long ptr long ptr long long) kernel32.GetQueuedCompletionStatusEx # @ stub GetRegistryExtensionFlags # @ stub GetRoamingLastObservedChangeTime @ stdcall GetSecurityDescriptorControl(ptr ptr ptr) advapi32.GetSecurityDescriptorControl diff --git a/include/winbase.h b/include/winbase.h index 4d959d0da6..de52e5a55b 100644 --- a/include/winbase.h +++ b/include/winbase.h @@ -565,6 +565,13 @@ typedef struct _OVERLAPPED { HANDLE hEvent; } OVERLAPPED, *LPOVERLAPPED; +typedef struct _OVERLAPPED_ENTRY { + ULONG_PTR lpCompletionKey; + LPOVERLAPPED lpOverlapped; + ULONG_PTR Internal; + DWORD dwNumberOfBytesTransferred; +} OVERLAPPED_ENTRY, *LPOVERLAPPED_ENTRY; + typedef VOID (CALLBACK *LPOVERLAPPED_COMPLETION_ROUTINE)(DWORD,DWORD,LPOVERLAPPED); /* Process startup information. -- 2.19.0

1 0

[PATCH] find: First simple implementation and tests
by Fabian Maurer 23 Sep '18

23 Sep '18

The message text is the same as on windows, since the exit code doesn't seem reliable. v2: Read input text line by line v3: Use unicode v4: Use buffered reading Signed-off-by: Fabian Maurer <dark.shadow4(a)web.de> --- programs/find/Makefile.in | 3 + programs/find/find.c | 171 ++++++++++++++++++++++- programs/find/resources.h | 27 ++++ programs/find/rsrc.rc | 25 ++++ programs/find/tests/Makefile.in | 5 + programs/find/tests/find.c | 231 ++++++++++++++++++++++++++++++++ 6 files changed, 458 insertions(+), 4 deletions(-) create mode 100644 programs/find/resources.h create mode 100644 programs/find/rsrc.rc create mode 100644 programs/find/tests/Makefile.in create mode 100644 programs/find/tests/find.c diff --git a/programs/find/Makefile.in b/programs/find/Makefile.in index ef8d61b7ce..edc23ec094 100644 --- a/programs/find/Makefile.in +++ b/programs/find/Makefile.in @@ -1,4 +1,7 @@ MODULE = find.exe APPMODE = -mconsole -municode +IMPORTS = user32 shlwapi C_SRCS = find.c + +RC_SRCS = rsrc.rc diff --git a/programs/find/find.c b/programs/find/find.c index 9d7aecd402..d181cf23df 100644 --- a/programs/find/find.c +++ b/programs/find/find.c @@ -16,18 +16,181 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ +#include <windows.h> +#include <stdlib.h> +#include <shlwapi.h> + +#include "wine/heap.h" #include "wine/debug.h" +#include "resources.h" WINE_DEFAULT_DEBUG_CHANNEL(find); +BOOL read_char_from_handle(HANDLE handle, char *char_out) +{ + static char buffer[4096]; + static UINT buffer_max = 0; + static UINT buffer_pos = 0; + + /* Read next content into buffer */ + if (buffer_pos >= buffer_max) + { + BOOL success = ReadFile(handle, buffer, 4096, &buffer_max, NULL); + if (!success) + return FALSE; + buffer_pos = 0; + } + + *char_out = buffer[buffer_pos++]; + return TRUE; +} + +/* Reads a line from a handle, returns TRUE if there is more to be read */ +BOOL read_line_from_handle(HANDLE handle, WCHAR **line_out) +{ + int buffer_size = 4096; + char c; + int length = 0; + WCHAR *line_converted; + int line_converted_length; + BOOL success; + char *line = heap_alloc(buffer_size); + + for (;;) + { + success = read_char_from_handle(handle, &c); + + /* Check for EOF */ + if (!success) + { + if (length == 0) + return FALSE; + else + break; + } + + if (c == '\n') + break; + + /* Make sure buffer is large enough */ + if (length + 1 >= buffer_size) + { + buffer_size *= 2; + line = heap_realloc(line, buffer_size); + } + + line[length++] = c; + } + + line[length] = 0; + if (length - 1 >= 0 && line[length - 1] == '\r') + line[length - 1] = 0; + + line_converted_length = MultiByteToWideChar(CP_ACP, 0, line, -1, 0, 0); + line_converted = heap_alloc(line_converted_length * sizeof(WCHAR)); + MultiByteToWideChar(CP_ACP, 0, line, -1, line_converted, line_converted_length); + + heap_free(line); + + *line_out = line_converted; + return TRUE; +} + +void write_to_handle(HANDLE handle, const WCHAR *str) +{ + DWORD bytes_written_sum = 0; + char *str_converted; + UINT str_converted_length; + UINT str_length = lstrlenW(str); + + str_converted_length = WideCharToMultiByte(CP_ACP, 0, str, str_length, NULL, 0, NULL, NULL); + str_converted = heap_alloc(str_converted_length); + WideCharToMultiByte(CP_ACP, 0, str, str_length, str_converted, str_converted_length, NULL, NULL); + + do + { + DWORD bytes_written; + WriteFile(handle, str_converted, str_converted_length, &bytes_written, NULL); + bytes_written_sum += bytes_written; + } while (bytes_written_sum < str_converted_length); + + heap_free(str_converted); +} + +void find_printf(const WCHAR *str) +{ + write_to_handle(GetStdHandle(STD_OUTPUT_HANDLE), str); +} + +BOOL run_find_for_line(const WCHAR *line, const WCHAR *tofind) +{ + void *found; + WCHAR lineending[] = {'\r', '\n', 0}; + + if (lstrlenW(line) == 0) + return FALSE; + + found = StrStrW(line, tofind); + + if (found) + { + find_printf(line); + find_printf(lineending); + return TRUE; + } + + return FALSE; +} + int wmain(int argc, WCHAR *argv[]) { + WCHAR *line; + WCHAR *tofind = NULL; + WCHAR message_parameter_invalid[64]; + WCHAR message_switch_invalid[64]; int i; + int exitcode; + HANDLE input; - WINE_FIXME("stub:"); + TRACE("running find:"); for (i = 0; i < argc; i++) - WINE_FIXME(" %s", wine_dbgstr_w(argv[i])); - WINE_FIXME("\n"); + { + TRACE(" %s", wine_dbgstr_w(argv[i])); + } + TRACE("\n"); + + LoadStringW(GetModuleHandleW(NULL), IDS_INVALID_PARAMETER, message_parameter_invalid, sizeof(message_parameter_invalid)); + LoadStringW(GetModuleHandleW(NULL), IDS_INVALID_SWITCH, message_switch_invalid, sizeof(message_switch_invalid)); + + input = GetStdHandle(STD_INPUT_HANDLE); + + for (i = 1; i < argc; i++) + { + if (argv[i][0] == '/') + { + find_printf(message_switch_invalid); + return 2; + } + else if(tofind == NULL) + { + tofind = argv[i]; + } + } + + if (tofind == NULL) + { + find_printf(message_parameter_invalid); + return 2; + } + + exitcode = 1; + while (read_line_from_handle(input, &line)) + { + if (run_find_for_line(line, tofind)) + exitcode = 0; + + heap_free(line); + } - return 0; + return exitcode; } diff --git a/programs/find/resources.h b/programs/find/resources.h new file mode 100644 index 0000000000..8712d91e36 --- /dev/null +++ b/programs/find/resources.h @@ -0,0 +1,27 @@ +/* + * Resource IDs + * + * Copyright 2018 Fabian Maurer + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_FIND_RESOURCES_H +#define __WINE_FIND_RESOURCES_H + +#define IDS_INVALID_PARAMETER 1000 +#define IDS_INVALID_SWITCH 1001 + +#endif /* __WINE_FIND_RESOURCES_H */ diff --git a/programs/find/rsrc.rc b/programs/find/rsrc.rc new file mode 100644 index 0000000000..f10fb6285f --- /dev/null +++ b/programs/find/rsrc.rc @@ -0,0 +1,25 @@ +/* + * Copyright 2018 Fabian Maurer + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "resources.h" + +STRINGTABLE +{ + IDS_INVALID_PARAMETER "FIND: Parameter format not correct\r\n" + IDS_INVALID_SWITCH "FIND: Invalid switch\r\n" +} diff --git a/programs/find/tests/Makefile.in b/programs/find/tests/Makefile.in new file mode 100644 index 0000000000..c5b359bd98 --- /dev/null +++ b/programs/find/tests/Makefile.in @@ -0,0 +1,5 @@ +TESTDLL = find.exe +IMPORTS = user32 + +C_SRCS = \ + find.c diff --git a/programs/find/tests/find.c b/programs/find/tests/find.c new file mode 100644 index 0000000000..fa10919c8d --- /dev/null +++ b/programs/find/tests/find.c @@ -0,0 +1,231 @@ +/* + * Copyright 2018 Fabian Maurer + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include <windows.h> +#include <stdio.h> + +#include "wine/heap.h" +#include "wine/test.h" + +WCHAR* read_all_from_handle(HANDLE handle) +{ + char buffer[4096]; + DWORD bytes_read; + DWORD length = 0; + BOOL success; + char *ret = heap_alloc_zero(1); + WCHAR *ret_converted; + int ret_converted_length; + + for (;;) + { + success = ReadFile(handle, buffer, sizeof(buffer), &bytes_read, NULL); + if (!success || !bytes_read) + break; + ret = heap_realloc(ret, length + bytes_read); + memcpy((char *)ret + length, buffer, bytes_read); + length += bytes_read; + } + + ret[length] = 0; + + ret_converted_length = MultiByteToWideChar(CP_UTF8, 0, ret, -1, 0, 0); + ret_converted = heap_alloc(ret_converted_length * sizeof(WCHAR)); + MultiByteToWideChar(CP_UTF8, 0, ret, -1, ret_converted, ret_converted_length); + + heap_free(ret); + + return ret_converted; +} + +/* Copied from find.exe implementation */ +void write_to_handle(HANDLE handle, const WCHAR *str) +{ + DWORD bytes_written_sum = 0; + char *str_converted; + UINT str_converted_length; + UINT str_length = lstrlenW(str); + + str_converted_length = WideCharToMultiByte(CP_UTF8, 0, str, str_length, NULL, 0, NULL, NULL); + str_converted = heap_alloc(str_converted_length); + WideCharToMultiByte(CP_UTF8, 0, str, str_length, str_converted, str_converted_length, NULL, NULL); + + do + { + DWORD bytes_written; + WriteFile(handle, str_converted, str_converted_length, &bytes_written, NULL); + bytes_written_sum += bytes_written; + } while (bytes_written_sum < str_converted_length); + + heap_free(str_converted); +} + +#define run_findW(commandline, input, out_expected, exitcode_expected) \ + run_findW_(commandline, input, out_expected, exitcode_expected, __FILE__, __LINE__) + +static void run_findW_(const WCHAR *commandline, const WCHAR *input, const WCHAR *out_expected, int exitcode_expected, const char *file, int line) +{ + static const WCHAR find_exe[] = {'f','i','n','d','.','e','x','e',' ','%','s'}; + HANDLE child_stdin_read; + HANDLE child_stdout_write; + HANDLE parent_stdin_write; + HANDLE parent_stdout_read; + STARTUPINFOW startup_info = {0}; + SECURITY_ATTRIBUTES security_attributes; + PROCESS_INFORMATION process_info = {0}; + WCHAR *child_output = NULL; + WCHAR cmd[4096]; + int comparison; + DWORD exitcode; + + security_attributes.nLength = sizeof(SECURITY_ATTRIBUTES); + security_attributes.bInheritHandle = TRUE; + security_attributes.lpSecurityDescriptor = NULL; + + CreatePipe(&parent_stdout_read, &child_stdout_write, &security_attributes, 0); + CreatePipe(&child_stdin_read, &parent_stdin_write, &security_attributes, 0); + + SetHandleInformation(parent_stdout_read, HANDLE_FLAG_INHERIT, 0); + SetHandleInformation(parent_stdin_write, HANDLE_FLAG_INHERIT, 0); + + startup_info.cb = sizeof(STARTUPINFOW); + startup_info.hStdInput = child_stdin_read; + startup_info.hStdOutput = child_stdout_write; + startup_info.hStdError = NULL; + startup_info.dwFlags |= STARTF_USESTDHANDLES; + + wsprintfW(cmd, find_exe, commandline); + CreateProcessW(NULL, cmd, NULL, NULL, TRUE, 0, NULL, NULL, &startup_info, &process_info); + CloseHandle(child_stdin_read); + CloseHandle(child_stdout_write); + + write_to_handle(parent_stdin_write, input); + CloseHandle(parent_stdin_write); + + child_output = read_all_from_handle(parent_stdout_read); + CloseHandle(parent_stdout_read); + + GetExitCodeProcess(process_info.hProcess, &exitcode); + CloseHandle(process_info.hProcess); + CloseHandle(process_info.hThread); + + comparison = lstrcmpW(child_output, out_expected); + + ok_(file, line)(comparison == 0, "\n#################### Expected:\n" + "%s\n" + "#################### But got:\n" + "%s\n" + "####################\n", + wine_dbgstr_w(out_expected), wine_dbgstr_w(child_output)); + ok_(file, line)(exitcode == exitcode_expected, "Expected exitcode %d, got %d\n", exitcode_expected, exitcode); + + heap_free(child_output); +} + +#define run_findA(commandline, input, out_expected, exitcode_expected) \ + run_findA_(commandline, input, out_expected, exitcode_expected, __FILE__, __LINE__) + +static void run_findA_(const char *commandline, const char *input, const char *out_expected, int exitcode_expected, const char *file, int line) +{ + WCHAR *commandlineW; + WCHAR *inputW; + WCHAR *out_expectedW; + int len_commandlineW, len_inputW, len_out_expectedW; + + + len_commandlineW = MultiByteToWideChar(CP_UTF8, 0, commandline, -1, 0, 0); + commandlineW = heap_alloc(len_commandlineW * sizeof(WCHAR)); + MultiByteToWideChar(CP_UTF8, 0, commandline, -1, commandlineW, len_commandlineW); + + len_inputW = MultiByteToWideChar(CP_UTF8, 0, input, -1, 0, 0); + inputW = heap_alloc(len_inputW * sizeof(WCHAR)); + MultiByteToWideChar(CP_UTF8, 0, input, -1, inputW, len_inputW); + + len_out_expectedW = MultiByteToWideChar(CP_UTF8, 0, out_expected, -1, 0, 0); + out_expectedW = heap_alloc(len_out_expectedW * sizeof(WCHAR)); + MultiByteToWideChar(CP_UTF8, 0, out_expected, -1, out_expectedW, len_out_expectedW); + + run_findW_(commandlineW, inputW, out_expectedW, exitcode_expected, file, line); + + heap_free(commandlineW); + heap_free(inputW); + heap_free(out_expectedW); +} + +static void test_errors(void) +{ + run_findA("", "", "FIND: Parameter format not correct\r\n", 2); + todo_wine + run_findA("test", "", "FIND: Parameter format not correct\r\n", 2); + todo_wine + run_findA("\"test", "", "FIND: Parameter format not correct\r\n", 2); + run_findA("\"test\" /XYZ", "", "FIND: Invalid switch\r\n", 2); +} + +static void test_singleline_without_switches(void) +{ + run_findA("\"\"", "test", "", 1); + run_findA("\"test\"", "", "", 1); + run_findA("\"test\"", "test", "test\r\n", 0); + run_findA("\"test\"", "test2", "test2\r\n", 0); + run_findA("\"test2\"", "test", "", 1); + +} + +static void test_multiline(void) +{ + /* Newline in input shouldn't work */ + run_findA("\"t1\r\nt1\"", "t1\r\nt1", "", 1); + run_findA("\"t1\nt1\"", "t1\nt1", "", 1); + + /* Newline should always be displayed as \r\n */ + run_findA("\"test1\"", "test1\ntest2", "test1\r\n", 0); + run_findA("\"test1\"", "test1\r\ntest2", "test1\r\n", 0); + + /* Test with empty line */ + run_findA("\"test1\"", "test1\n\ntest2", "test1\r\n", 0); + + /* Two strings to be found */ + run_findA("\"test\"", "junk1\ntest1\ntest2\r\njunk", "test1\r\ntest2\r\n", 0); +} + +static void test_unicode_support(void) +{ + static const WCHAR str_empty[] = {0}; + static const WCHAR str_hello_in_russian[] = {'H', 'e', 'l', 'l', 'o', ' ', 0x043F, 0x0440, 0x0438, 0x0432, 0x0435, 0x0442, 0}; + static const WCHAR str_quoted_part_of_hello_in_russian[] = {'"', 0x0438, 0x0432, 0x0435, '"', 0}; + static const WCHAR str_hello_in_russian_with_endl[] = {'H', 'e', 'l', 'l', 'o', ' ', 0x043F, 0x0440, 0x0438, 0x0432, 0x0435, 0x0442, '\r', '\n', 0}; + static const WCHAR str_quoted_hello[] = {'"', 'H', 'e', 'l', 'l', 'o', '"', 0}; + + run_findW(str_quoted_hello, str_hello_in_russian, str_hello_in_russian_with_endl, 0); + run_findW(str_quoted_part_of_hello_in_russian, str_hello_in_russian, str_empty, 1); +} + +START_TEST(find) +{ + if (PRIMARYLANGID(GetUserDefaultUILanguage()) != LANG_ENGLISH) + { + skip("Tests only work with english locale.\n"); + return; + } + + test_errors(); + test_singleline_without_switches(); + test_multiline(); + test_unicode_support(); +} -- 2.19.0

2 5

[PATCH] wininet/tests: Skip tests when querying INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT fails (newer win10)
by André Hentschel 22 Sep '18

22 Sep '18

Signed-off-by: André Hentschel <nerv(a)dawncrow.de> --- dlls/wininet/tests/http.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/dlls/wininet/tests/http.c b/dlls/wininet/tests/http.c index ace8512399..9ec4902cdc 100644 --- a/dlls/wininet/tests/http.c +++ b/dlls/wininet/tests/http.c @@ -5569,6 +5569,12 @@ static void test_cert_struct(HINTERNET req, const cert_struct_test_t *test) size = sizeof(info); res = InternetQueryOptionA(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT, &info, &size); + if (!res) + { + win_skip("Querying INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT failed, skipping tests\n"); + return; + } + ok(res, "InternetQueryOption failed: %u\n", GetLastError()); ok(size == sizeof(info), "size = %u\n", size); -- 2.17.1

2 2

[PATCH] wine.inf: Add a ProfileList\<UserSID> registry subkey.
by Alex Henrie 22 Sep '18

22 Sep '18

From: Sebastian Lackner <sebastian(a)fds-team.de> Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=15670 Signed-off-by: Alex Henrie <alexhenrie24(a)gmail.com> --- loader/wine.inf.in | 2 ++ 1 file changed, 2 insertions(+) diff --git a/loader/wine.inf.in b/loader/wine.inf.in index 5767b29887..5c4da2f756 100644 --- a/loader/wine.inf.in +++ b/loader/wine.inf.in @@ -527,6 +527,8 @@ HKLM,%CurrentVersionNT%\Perflib,,16 HKLM,%CurrentVersionNT%\Ports,,16 HKLM,%CurrentVersionNT%\Print,,16 HKLM,%CurrentVersionNT%\ProfileList,,16 +; Update/Replace if local_user_sid in server/token.c changes +HKLM,%CurrentVersionNT%\ProfileList\S-1-5-21-0-0-0-1000,,16 [CurrentVersionWow64] HKLM,%CurrentVersion%,"ProgramFilesDir (x86)",,"%16426%" -- 2.19.0

2 3

[PATCH 2/5] d3d9/tests: Properly check whether creating a device succeeded in test_flip().
by Henri Verbeet 22 Sep '18

22 Sep '18

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/d3d9/tests/visual.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c index 9c3e83d3005..4f26b0d23f9 100644 --- a/dlls/d3d9/tests/visual.c +++ b/dlls/d3d9/tests/visual.c @@ -20984,9 +20984,8 @@ static void test_flip(void) present_parameters.Windowed = TRUE; present_parameters.BackBufferCount = 3; present_parameters.Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER; - hr = IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, - window, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device); - if (!device) + if (FAILED(hr = IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, + window, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device))) { skip("Failed to create a D3D device, skipping tests.\n"); IDirect3D9_Release(d3d); -- 2.11.0

2 1

[PATCH 5/5] wined3d: Move the OpenGL texture format to struct wined3d_format_gl.
by Henri Verbeet 21 Sep '18

21 Sep '18

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/context.c | 4 +- dlls/wined3d/surface.c | 48 ++-- dlls/wined3d/texture.c | 93 ++++---- dlls/wined3d/utils.c | 485 +++++++++++++++++++++-------------------- dlls/wined3d/view.c | 30 +-- dlls/wined3d/wined3d_private.h | 11 +- 6 files changed, 349 insertions(+), 322 deletions(-) diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c index 167241a6f0f..8199afa1d0e 100644 --- a/dlls/wined3d/context.c +++ b/dlls/wined3d/context.c @@ -3868,6 +3868,7 @@ static void context_bind_unordered_access_views(struct wined3d_context *context, { const struct wined3d_gl_info *gl_info = context->gl_info; struct wined3d_unordered_access_view *view; + const struct wined3d_format_gl *format_gl; GLuint texture_name; unsigned int i; GLint level; @@ -3903,8 +3904,9 @@ static void context_bind_unordered_access_views(struct wined3d_context *context, continue; } + format_gl = wined3d_format_gl(view->format); GL_EXTCALL(glBindImageTexture(i, texture_name, level, GL_TRUE, 0, GL_READ_WRITE, - view->format->glInternal)); + format_gl->internal)); if (view->counter_bo) GL_EXTCALL(glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, i, view->counter_bo)); diff --git a/dlls/wined3d/surface.c b/dlls/wined3d/surface.c index d1847bea34e..8b69720693e 100644 --- a/dlls/wined3d/surface.c +++ b/dlls/wined3d/surface.c @@ -348,22 +348,24 @@ static BOOL fbo_blitter_supported(enum wined3d_blit_op blit_op, const struct win static void texture2d_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, const struct wined3d_context *context, DWORD dst_location) { - const struct wined3d_format *format = texture->resource.format; const struct wined3d_gl_info *gl_info = context->gl_info; struct wined3d_texture_sub_resource *sub_resource; unsigned int dst_row_pitch, dst_slice_pitch; unsigned int src_row_pitch, src_slice_pitch; + const struct wined3d_format_gl *format_gl; struct wined3d_bo_address data; BYTE *temporary_mem = NULL; unsigned int level; GLenum target; void *mem; + format_gl = wined3d_format_gl(texture->resource.format); + /* Only support read back of converted P8 textures. */ - if (texture->flags & WINED3D_TEXTURE_CONVERTED && format->id != WINED3DFMT_P8_UINT && !format->download) + if (texture->flags & WINED3D_TEXTURE_CONVERTED && format_gl->f.id != WINED3DFMT_P8_UINT && !format_gl->f.download) { ERR("Trying to read back converted texture %p, %u with format %s.\n", - texture, sub_resource_idx, debug_d3dformat(format->id)); + texture, sub_resource_idx, debug_d3dformat(format_gl->f.id)); return; } @@ -373,7 +375,7 @@ static void texture2d_download_data(struct wined3d_texture *texture, unsigned in if (target == GL_TEXTURE_2D_ARRAY) { - if (format->download) + if (format_gl->f.download) { FIXME("Reading back converted array texture %p is not supported.\n", texture); return; @@ -396,14 +398,14 @@ static void texture2d_download_data(struct wined3d_texture *texture, unsigned in if (texture->flags & WINED3D_TEXTURE_COND_NP2_EMULATED) { - if (format->download) + if (format_gl->f.download) { FIXME("Reading back converted texture %p with NP2 emulation is not supported.\n", texture); return; } wined3d_texture_get_pitch(texture, level, &dst_row_pitch, &dst_slice_pitch); - wined3d_format_calculate_pitch(format, texture->resource.device->surface_alignment, + wined3d_format_calculate_pitch(&format_gl->f, texture->resource.device->surface_alignment, wined3d_texture_get_level_pow2_width(texture, level), wined3d_texture_get_level_pow2_height(texture, level), &src_row_pitch, &src_slice_pitch); @@ -419,7 +421,7 @@ static void texture2d_download_data(struct wined3d_texture *texture, unsigned in ERR("Unexpected compressed format for NP2 emulated texture.\n"); } - if (format->download) + if (format_gl->f.download) { struct wined3d_format f; @@ -427,10 +429,10 @@ static void texture2d_download_data(struct wined3d_texture *texture, unsigned in ERR("Converted texture %p uses PBO unexpectedly.\n", texture); WARN_(d3d_perf)("Downloading converted texture %p, %u with format %s.\n", - texture, sub_resource_idx, debug_d3dformat(format->id)); + texture, sub_resource_idx, debug_d3dformat(format_gl->f.id)); - f = *format; - f.byte_count = format->conv_byte_count; + f = format_gl->f; + f.byte_count = format_gl->f.conv_byte_count; wined3d_texture_get_pitch(texture, level, &dst_row_pitch, &dst_slice_pitch); wined3d_format_calculate_pitch(&f, texture->resource.device->surface_alignment, wined3d_texture_get_level_width(texture, level), @@ -462,7 +464,7 @@ static void texture2d_download_data(struct wined3d_texture *texture, unsigned in if (texture->resource.format_flags & WINED3DFMT_FLAG_COMPRESSED) { TRACE("Downloading compressed texture %p, %u, level %u, format %#x, type %#x, data %p.\n", - texture, sub_resource_idx, level, format->glFormat, format->glType, mem); + texture, sub_resource_idx, level, format_gl->format, format_gl->type, mem); GL_EXTCALL(glGetCompressedTexImage(target, level, mem)); checkGLcall("glGetCompressedTexImage"); @@ -470,15 +472,15 @@ static void texture2d_download_data(struct wined3d_texture *texture, unsigned in else { TRACE("Downloading texture %p, %u, level %u, format %#x, type %#x, data %p.\n", - texture, sub_resource_idx, level, format->glFormat, format->glType, mem); + texture, sub_resource_idx, level, format_gl->format, format_gl->type, mem); - gl_info->gl_ops.gl.p_glGetTexImage(target, level, format->glFormat, format->glType, mem); + gl_info->gl_ops.gl.p_glGetTexImage(target, level, format_gl->format, format_gl->type, mem); checkGLcall("glGetTexImage"); } - if (format->download) + if (format_gl->f.download) { - format->download(mem, data.addr, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, + format_gl->f.download(mem, data.addr, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, wined3d_texture_get_level_width(texture, level), wined3d_texture_get_level_height(texture, level), 1); } @@ -931,7 +933,9 @@ static struct wined3d_texture *surface_convert_format(struct wined3d_texture *sr static void texture2d_read_from_framebuffer(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_context *context, DWORD src_location, DWORD dst_location) { - struct wined3d_device *device = texture->resource.device; + struct wined3d_resource *resource = &texture->resource; + struct wined3d_device *device = resource->device; + const struct wined3d_format_gl *format_gl; struct wined3d_texture *restore_texture; const struct wined3d_gl_info *gl_info; unsigned int row_pitch, slice_pitch; @@ -953,10 +957,10 @@ static void texture2d_read_from_framebuffer(struct wined3d_texture *texture, uns restore_texture = NULL; gl_info = context->gl_info; - if (src_location != texture->resource.draw_binding) + if (src_location != resource->draw_binding) { context_apply_fbo_state_blit(context, GL_READ_FRAMEBUFFER, - &texture->resource, sub_resource_idx, NULL, 0, src_location); + resource, sub_resource_idx, NULL, 0, src_location); context_check_fbo_status(context, GL_READ_FRAMEBUFFER); context_invalidate_state(context, STATE_FRAMEBUFFER); } @@ -969,7 +973,7 @@ static void texture2d_read_from_framebuffer(struct wined3d_texture *texture, uns * There is no need to keep track of the current read buffer or reset it, * every part of the code that reads sets the read buffer as desired. */ - if (src_location != WINED3D_LOCATION_DRAWABLE || wined3d_resource_is_offscreen(&texture->resource)) + if (src_location != WINED3D_LOCATION_DRAWABLE || wined3d_resource_is_offscreen(resource)) { /* Mapping the primary render target which is not on a swapchain. * Read from the back buffer. */ @@ -995,16 +999,16 @@ static void texture2d_read_from_framebuffer(struct wined3d_texture *texture, uns level = sub_resource_idx % texture->level_count; wined3d_texture_get_pitch(texture, level, &row_pitch, &slice_pitch); + format_gl = wined3d_format_gl(resource->format); /* Setup pixel store pack state -- to glReadPixels into the correct place */ - gl_info->gl_ops.gl.p_glPixelStorei(GL_PACK_ROW_LENGTH, row_pitch / texture->resource.format->byte_count); + gl_info->gl_ops.gl.p_glPixelStorei(GL_PACK_ROW_LENGTH, row_pitch / format_gl->f.byte_count); checkGLcall("glPixelStorei"); width = wined3d_texture_get_level_width(texture, level); height = wined3d_texture_get_level_height(texture, level); gl_info->gl_ops.gl.p_glReadPixels(0, 0, width, height, - texture->resource.format->glFormat, - texture->resource.format->glType, data.addr); + format_gl->format, format_gl->type, data.addr); checkGLcall("glReadPixels"); /* Reset previous pixel store pack state */ diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c index b878e38961e..fdf26512b91 100644 --- a/dlls/wined3d/texture.c +++ b/dlls/wined3d/texture.c @@ -561,7 +561,7 @@ static unsigned int wined3d_texture_get_gl_sample_count(const struct wined3d_tex /* Context activation is done by the caller. */ /* The caller is responsible for binding the correct texture. */ static void wined3d_texture_allocate_gl_mutable_storage(struct wined3d_texture *texture, - GLenum gl_internal_format, const struct wined3d_format *format, + GLenum gl_internal_format, const struct wined3d_format_gl *format, const struct wined3d_gl_info *gl_info) { unsigned int level, level_count, layer, layer_count; @@ -584,8 +584,8 @@ static void wined3d_texture_allocate_gl_mutable_storage(struct wined3d_texture * height = wined3d_texture_get_level_pow2_height(texture, level); if (texture->resource.format_flags & WINED3DFMT_FLAG_HEIGHT_SCALE) { - height *= format->height_scale.numerator; - height /= format->height_scale.denominator; + height *= format->f.height_scale.numerator; + height /= format->f.height_scale.denominator; } TRACE("texture %p, layer %u, level %u, target %#x, width %u, height %u.\n", @@ -596,19 +596,19 @@ static void wined3d_texture_allocate_gl_mutable_storage(struct wined3d_texture * depth = wined3d_texture_get_level_depth(texture, level); GL_EXTCALL(glTexImage3D(target, level, gl_internal_format, width, height, target == GL_TEXTURE_2D_ARRAY ? texture->layer_count : depth, 0, - format->glFormat, format->glType, NULL)); + format->format, format->type, NULL)); checkGLcall("glTexImage3D"); } else if (target == GL_TEXTURE_1D) { gl_info->gl_ops.gl.p_glTexImage1D(target, level, gl_internal_format, - width, 0, format->glFormat, format->glType, NULL); + width, 0, format->format, format->type, NULL); } else { gl_info->gl_ops.gl.p_glTexImage2D(target, level, gl_internal_format, width, target == GL_TEXTURE_1D_ARRAY ? texture->layer_count : height, 0, - format->glFormat, format->glType, NULL); + format->format, format->type, NULL); checkGLcall("glTexImage2D"); } } @@ -1513,10 +1513,12 @@ void wined3d_texture_set_compatible_renderbuffer(struct wined3d_texture *texture if (!renderbuffer) { + const struct wined3d_format_gl *format_gl; + + format_gl = wined3d_format_gl(texture->resource.format); gl_info->fbo_ops.glGenRenderbuffers(1, &renderbuffer); gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer); - gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, - texture->resource.format->glInternal, width, height); + gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, format_gl->internal, width, height); entry = heap_alloc(sizeof(*entry)); entry->width = width; @@ -1712,11 +1714,13 @@ static void wined3d_texture_force_reload(struct wined3d_texture *texture) void wined3d_texture_prepare_texture(struct wined3d_texture *texture, struct wined3d_context *context, BOOL srgb) { DWORD alloc_flag = srgb ? WINED3D_TEXTURE_SRGB_ALLOCATED : WINED3D_TEXTURE_RGB_ALLOCATED; - const struct wined3d_device *device = texture->resource.device; - const struct wined3d_format *format = texture->resource.format; const struct wined3d_d3d_info *d3d_info = context->d3d_info; const struct wined3d_gl_info *gl_info = context->gl_info; + struct wined3d_resource *resource = &texture->resource; + const struct wined3d_device *device = resource->device; + const struct wined3d_format *format = resource->format; const struct wined3d_color_key_conversion *conversion; + const struct wined3d_format_gl *format_gl; GLenum internal; TRACE("texture %p, context %p, format %s.\n", texture, context, debug_d3dformat(format->id)); @@ -1734,11 +1738,11 @@ void wined3d_texture_prepare_texture(struct wined3d_texture *texture, struct win if (texture->flags & alloc_flag) return; - if (texture->resource.format_flags & WINED3DFMT_FLAG_DECOMPRESS) + if (resource->format_flags & WINED3DFMT_FLAG_DECOMPRESS) { TRACE("WINED3DFMT_FLAG_DECOMPRESS set.\n"); texture->flags |= WINED3D_TEXTURE_CONVERTED; - format = wined3d_resource_get_decompress_format(&texture->resource); + format = wined3d_resource_get_decompress_format(resource); } else if (format->conv_byte_count) { @@ -1747,37 +1751,38 @@ void wined3d_texture_prepare_texture(struct wined3d_texture *texture, struct win else if ((conversion = wined3d_format_get_color_key_conversion(texture, TRUE))) { texture->flags |= WINED3D_TEXTURE_CONVERTED; - format = wined3d_get_format(device->adapter, conversion->dst_format, texture->resource.usage); + format = wined3d_get_format(device->adapter, conversion->dst_format, resource->usage); TRACE("Using format %s for color key conversion.\n", debug_d3dformat(format->id)); } + format_gl = wined3d_format_gl(format); wined3d_texture_bind_and_dirtify(texture, context, srgb); if (srgb) - internal = format->glGammaInternal; - else if (texture->resource.usage & WINED3DUSAGE_RENDERTARGET - && wined3d_resource_is_offscreen(&texture->resource)) - internal = format->rtInternal; + internal = format_gl->srgb_internal; + else if (resource->usage & WINED3DUSAGE_RENDERTARGET && wined3d_resource_is_offscreen(resource)) + internal = format_gl->rt_internal; else - internal = format->glInternal; + internal = format_gl->internal; if (!internal) FIXME("No GL internal format for format %s.\n", debug_d3dformat(format->id)); - TRACE("internal %#x, format %#x, type %#x.\n", internal, format->glFormat, format->glType); + TRACE("internal %#x, format %#x, type %#x.\n", internal, format_gl->format, format_gl->type); if (wined3d_texture_use_immutable_storage(texture, gl_info)) wined3d_texture_allocate_gl_immutable_storage(texture, internal, gl_info); else - wined3d_texture_allocate_gl_mutable_storage(texture, internal, format, gl_info); + wined3d_texture_allocate_gl_mutable_storage(texture, internal, format_gl, gl_info); texture->flags |= alloc_flag; } static void wined3d_texture_prepare_rb(struct wined3d_texture *texture, const struct wined3d_gl_info *gl_info, BOOL multisample) { - const struct wined3d_format *format = texture->resource.format; + const struct wined3d_format_gl *format_gl; + format_gl = wined3d_format_gl(texture->resource.format); if (multisample) { DWORD samples; @@ -1790,7 +1795,7 @@ static void wined3d_texture_prepare_rb(struct wined3d_texture *texture, gl_info->fbo_ops.glGenRenderbuffers(1, &texture->rb_multisample); gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, texture->rb_multisample); gl_info->fbo_ops.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples, - format->glInternal, texture->resource.width, texture->resource.height); + format_gl->internal, texture->resource.width, texture->resource.height); checkGLcall("glRenderbufferStorageMultisample()"); TRACE("Created multisample rb %u.\n", texture->rb_multisample); } @@ -1801,7 +1806,7 @@ static void wined3d_texture_prepare_rb(struct wined3d_texture *texture, gl_info->fbo_ops.glGenRenderbuffers(1, &texture->rb_resolved); gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, texture->rb_resolved); - gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, format->glInternal, + gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, format_gl->internal, texture->resource.width, texture->resource.height); checkGLcall("glRenderbufferStorage()"); TRACE("Created resolved rb %u.\n", texture->rb_resolved); @@ -1906,9 +1911,10 @@ void wined3d_texture_upload_data(struct wined3d_texture *texture, unsigned int s unsigned int update_w = src_box->right - src_box->left; unsigned int update_h = src_box->bottom - src_box->top; unsigned int update_d = src_box->back - src_box->front; + const struct wined3d_format_gl *format_gl; struct wined3d_bo_address bo; void *converted_mem = NULL; - struct wined3d_format f; + struct wined3d_format_gl f; unsigned int level; BOOL decompress; GLenum target; @@ -1978,9 +1984,9 @@ void wined3d_texture_upload_data(struct wined3d_texture *texture, unsigned int s if (texture->resource.format_flags & WINED3DFMT_FLAG_BLOCKS) ERR("Converting a block-based format.\n"); - f = *format; - f.byte_count = format->conv_byte_count; - format = &f; + f = *wined3d_format_gl(format); + f.f.byte_count = format->conv_byte_count; + format = &f.f; } wined3d_format_calculate_pitch(format, 1, update_w, update_h, &dst_row_pitch, &dst_slice_pitch); @@ -2015,6 +2021,7 @@ void wined3d_texture_upload_data(struct wined3d_texture *texture, unsigned int s checkGLcall("glBindBuffer"); } + format_gl = wined3d_format_gl(format); if (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_COMPRESSED) { unsigned int dst_row_pitch, dst_slice_pitch; @@ -2022,12 +2029,12 @@ void wined3d_texture_upload_data(struct wined3d_texture *texture, unsigned int s GLenum internal; if (srgb) - internal = format->glGammaInternal; + internal = format_gl->srgb_internal; else if (texture->resource.usage & WINED3DUSAGE_RENDERTARGET && wined3d_resource_is_offscreen(&texture->resource)) - internal = format->rtInternal; + internal = format_gl->rt_internal; else - internal = format->glInternal; + internal = format_gl->internal; wined3d_format_calculate_pitch(format, 1, update_w, update_h, &dst_row_pitch, &dst_slice_pitch); @@ -2088,23 +2095,23 @@ void wined3d_texture_upload_data(struct wined3d_texture *texture, unsigned int s TRACE("Uploading data, target %#x, level %u, x %u, y %u, z %u, " "w %u, h %u, d %u, format %#x, type %#x, addr %p.\n", target, level, dst_x, dst_y, dst_z, update_w, update_h, - update_d, format->glFormat, format->glType, bo.addr); + update_d, format_gl->format, format_gl->type, bo.addr); gl_info->gl_ops.gl.p_glPixelStorei(GL_UNPACK_ROW_LENGTH, src_row_pitch / format->byte_count); if (target == GL_TEXTURE_2D_ARRAY || target == GL_TEXTURE_3D) { GL_EXTCALL(glTexSubImage3D(target, level, dst_x, dst_y, dst_z, - update_w, update_h, update_d, format->glFormat, format->glType, bo.addr)); + update_w, update_h, update_d, format_gl->format, format_gl->type, bo.addr)); } else if (target == GL_TEXTURE_1D) { gl_info->gl_ops.gl.p_glTexSubImage1D(target, level, dst_x, - update_w, format->glFormat, format->glType, bo.addr); + update_w, format_gl->format, format_gl->type, bo.addr); } else { gl_info->gl_ops.gl.p_glTexSubImage2D(target, level, dst_x, dst_y, - update_w, update_h, format->glFormat, format->glType, bo.addr); + update_w, update_h, format_gl->format, format_gl->type, bo.addr); } gl_info->gl_ops.gl.p_glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); checkGLcall("Upload texture data"); @@ -2437,13 +2444,14 @@ static const struct wined3d_resource_ops texture_resource_ops = static void texture1d_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, const struct wined3d_context *context, const struct wined3d_bo_address *data) { - const struct wined3d_format *format = texture->resource.format; const struct wined3d_gl_info *gl_info = context->gl_info; + const struct wined3d_format_gl *format_gl; - if (format->conv_byte_count) + format_gl = wined3d_format_gl(texture->resource.format); + if (format_gl->f.conv_byte_count) { FIXME("Attempting to download a converted texture, format %s.\n", - debug_d3dformat(format->id)); + debug_d3dformat(format_gl->f.id)); return; } @@ -2454,7 +2462,7 @@ static void texture1d_download_data(struct wined3d_texture *texture, unsigned in } gl_info->gl_ops.gl.p_glGetTexImage(texture->target, sub_resource_idx, - format->glFormat, format->glType, data->addr); + format_gl->format, format_gl->type, data->addr); checkGLcall("glGetTexImage"); if (data->buffer_object) @@ -2909,13 +2917,14 @@ static HRESULT wined3d_texture_init(struct wined3d_texture *texture, const struc static void texture3d_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, const struct wined3d_context *context, const struct wined3d_bo_address *data) { - const struct wined3d_format *format = texture->resource.format; const struct wined3d_gl_info *gl_info = context->gl_info; + const struct wined3d_format_gl *format_gl; - if (format->conv_byte_count) + format_gl = wined3d_format_gl(texture->resource.format); + if (format_gl->f.conv_byte_count) { FIXME("Attempting to download a converted volume, format %s.\n", - debug_d3dformat(format->id)); + debug_d3dformat(format_gl->f.id)); return; } @@ -2926,7 +2935,7 @@ static void texture3d_download_data(struct wined3d_texture *texture, unsigned in } gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_3D, sub_resource_idx, - format->glFormat, format->glType, data->addr); + format_gl->format, format_gl->type, data->addr); checkGLcall("glGetTexImage"); if (data->buffer_object) diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 36694856081..055d546ccba 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -1935,6 +1935,11 @@ static struct wined3d_format *get_format_by_idx(const struct wined3d_adapter *ad return (struct wined3d_format *)((BYTE *)adapter->formats + fmt_idx * adapter->format_size); } +static struct wined3d_format_gl *get_format_gl_by_idx(const struct wined3d_adapter *adapter, int fmt_idx) +{ + return wined3d_format_gl_mutable(get_format_by_idx(adapter, fmt_idx)); +} + static struct wined3d_format *get_format_internal(const struct wined3d_adapter *adapter, enum wined3d_format_id format_id) { @@ -2431,7 +2436,7 @@ static void draw_test_quad(struct wined3d_caps_gl_ctx *ctx, const struct wined3d } /* Context activation is done by the caller. */ -static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_format *format) +static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_format_gl *format) { /* Check if the default internal format is supported as a frame buffer * target, otherwise fall back to the render target internal. @@ -2440,24 +2445,24 @@ static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_for static const struct wined3d_color black = {0.0f, 0.0f, 0.0f, 1.0f}; static const struct wined3d_color half_transparent_red = {1.0f, 0.0f, 0.0f, 0.5f}; const struct wined3d_gl_info *gl_info = ctx->gl_info; - GLenum status, rt_internal = format->rtInternal; + GLenum status, rt_internal = format->rt_internal; GLuint object, color_rb; enum wined3d_gl_resource_type type; BOOL fallback_fmt_used = FALSE, regular_fmt_used = FALSE; gl_info->gl_ops.gl.p_glDisable(GL_BLEND); - for (type = 0; type < ARRAY_SIZE(format->flags); ++type) + for (type = 0; type < ARRAY_SIZE(format->f.flags); ++type) { const char *type_string = "color"; if (type == WINED3D_GL_RES_TYPE_BUFFER) continue; - create_and_bind_fbo_attachment(gl_info, format->flags[type], type, &object, format->glInternal, - format->glFormat, format->glType); + create_and_bind_fbo_attachment(gl_info, format->f.flags[type], type, + &object, format->internal, format->format, format->type); - if (format->flags[type] & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) + if (format->f.flags[type] & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) { gl_info->fbo_ops.glGenRenderbuffers(1, &color_rb); gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, color_rb); @@ -2478,39 +2483,39 @@ static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_for if (status == GL_FRAMEBUFFER_COMPLETE) { TRACE("Format %s is supported as FBO %s attachment, type %u.\n", - debug_d3dformat(format->id), type_string, type); - format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE; - format->rtInternal = format->glInternal; + debug_d3dformat(format->f.id), type_string, type); + format->f.flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE; + format->rt_internal = format->internal; regular_fmt_used = TRUE; } else { if (!rt_internal) { - if (format->flags[type] & WINED3DFMT_FLAG_RENDERTARGET) + if (format->f.flags[type] & WINED3DFMT_FLAG_RENDERTARGET) { WARN("Format %s with rendertarget flag is not supported as FBO color attachment (type %u)," - " and no fallback specified.\n", debug_d3dformat(format->id), type); - format->flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET; + " and no fallback specified.\n", debug_d3dformat(format->f.id), type); + format->f.flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET; } else { TRACE("Format %s is not supported as FBO %s attachment, type %u.\n", - debug_d3dformat(format->id), type_string, type); + debug_d3dformat(format->f.id), type_string, type); } - format->rtInternal = format->glInternal; + format->rt_internal = format->internal; } else { TRACE("Format %s is not supported as FBO %s attachment (type %u)," " trying rtInternal format as fallback.\n", - debug_d3dformat(format->id), type_string, type); + debug_d3dformat(format->f.id), type_string, type); while (gl_info->gl_ops.gl.p_glGetError()); delete_fbo_attachment(gl_info, type, object); - create_and_bind_fbo_attachment(gl_info, format->flags[type], type, &object, format->rtInternal, - format->glFormat, format->glType); + create_and_bind_fbo_attachment(gl_info, format->f.flags[type], type, + &object, format->rt_internal, format->format, format->type); status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER); checkGLcall("Framebuffer format check"); @@ -2518,25 +2523,25 @@ static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_for if (status == GL_FRAMEBUFFER_COMPLETE) { TRACE("Format %s rtInternal format is supported as FBO %s attachment, type %u.\n", - debug_d3dformat(format->id), type_string, type); + debug_d3dformat(format->f.id), type_string, type); fallback_fmt_used = TRUE; } else { WARN("Format %s rtInternal format is not supported as FBO %s attachment, type %u.\n", - debug_d3dformat(format->id), type_string, type); - format->flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET; + debug_d3dformat(format->f.id), type_string, type); + format->f.flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET; } } } if (status == GL_FRAMEBUFFER_COMPLETE - && ((format->flags[type] & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING) + && ((format->f.flags[type] & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING) || !(gl_info->quirks & WINED3D_QUIRK_LIMITED_TEX_FILTERING)) - && !(format->flags[type] & WINED3DFMT_FLAG_INTEGER) - && format->id != WINED3DFMT_NULL && format->id != WINED3DFMT_P8_UINT - && format->glFormat != GL_LUMINANCE && format->glFormat != GL_LUMINANCE_ALPHA - && (format->red_size || format->alpha_size)) + && !(format->f.flags[type] & WINED3DFMT_FLAG_INTEGER) + && format->f.id != WINED3DFMT_NULL && format->f.id != WINED3DFMT_P8_UINT + && format->format != GL_LUMINANCE && format->format != GL_LUMINANCE_ALPHA + && (format->f.red_size || format->f.alpha_size)) { DWORD readback[16 * 16 * 16], color, r_range, a_range; BYTE r, a; @@ -2564,8 +2569,8 @@ static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_for { while (gl_info->gl_ops.gl.p_glGetError()); TRACE("Format %s doesn't support post-pixelshader blending, type %u.\n", - debug_d3dformat(format->id), type); - format->flags[type] &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING; + debug_d3dformat(format->f.id), type); + format->f.flags[type] &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING; } else { @@ -2628,25 +2633,25 @@ static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_for a = color >> 24; r = (color & 0x00ff0000u) >> 16; - r_range = format->red_size < 8 ? 1u << (8 - format->red_size) : 1; - a_range = format->alpha_size < 8 ? 1u << (8 - format->alpha_size) : 1; - if (format->red_size && (r < 0x7f - r_range || r > 0x7f + r_range)) + r_range = format->f.red_size < 8 ? 1u << (8 - format->f.red_size) : 1; + a_range = format->f.alpha_size < 8 ? 1u << (8 - format->f.alpha_size) : 1; + if (format->f.red_size && (r < 0x7f - r_range || r > 0x7f + r_range)) match = FALSE; - else if (format->alpha_size > 1 && (a < 0xbf - a_range || a > 0xbf + a_range)) + else if (format->f.alpha_size > 1 && (a < 0xbf - a_range || a > 0xbf + a_range)) match = FALSE; if (!match) { TRACE("Format %s doesn't support post-pixelshader blending, type %u.\n", - debug_d3dformat(format->id), type); + debug_d3dformat(format->f.id), type); TRACE("Color output: %#x\n", color); - format->flags[type] &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING; + format->f.flags[type] &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING; } else { TRACE("Format %s supports post-pixelshader blending, type %u.\n", - debug_d3dformat(format->id), type); + debug_d3dformat(format->f.id), type); TRACE("Color output: %#x\n", color); - format->flags[type] |= WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING; + format->f.flags[type] |= WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING; } } @@ -2660,11 +2665,11 @@ static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_for } } - if (format->glInternal != format->glGammaInternal) + if (format->internal != format->srgb_internal) { delete_fbo_attachment(gl_info, type, object); - create_and_bind_fbo_attachment(gl_info, format->flags[type], type, &object, format->glGammaInternal, - format->glFormat, format->glType); + create_and_bind_fbo_attachment(gl_info, format->f.flags[type], type, &object, format->srgb_internal, + format->format, format->type); status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER); checkGLcall("Framebuffer format check"); @@ -2672,22 +2677,22 @@ static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_for if (status == GL_FRAMEBUFFER_COMPLETE) { TRACE("Format %s's sRGB format is FBO attachable, type %u.\n", - debug_d3dformat(format->id), type); - format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB; + debug_d3dformat(format->f.id), type); + format->f.flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB; if (gl_info->supported[EXT_TEXTURE_SRGB_DECODE]) - format->glInternal = format->glGammaInternal; + format->internal = format->srgb_internal; } else { WARN("Format %s's sRGB format is not FBO attachable, type %u.\n", - debug_d3dformat(format->id), type); - format_clear_flag(format, WINED3DFMT_FLAG_SRGB_WRITE); + debug_d3dformat(format->f.id), type); + format_clear_flag(&format->f, WINED3DFMT_FLAG_SRGB_WRITE); } } else if (status == GL_FRAMEBUFFER_COMPLETE) - format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB; + format->f.flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB; - if (format->flags[type] & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) + if (format->f.flags[type] & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) { gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, 0); gl_info->fbo_ops.glDeleteRenderbuffers(1, &color_rb); @@ -2700,30 +2705,30 @@ static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_for if (fallback_fmt_used && regular_fmt_used) { FIXME("Format %s needs different render target formats for different resource types.\n", - debug_d3dformat(format->id)); - format_clear_flag(format, WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_FBO_ATTACHABLE + debug_d3dformat(format->f.id)); + format_clear_flag(&format->f, WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_FBO_ATTACHABLE | WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING); } } -static void query_format_flag(struct wined3d_gl_info *gl_info, struct wined3d_format *format, +static void query_format_flag(struct wined3d_gl_info *gl_info, struct wined3d_format_gl *format, GLint internal, GLenum pname, DWORD flag, const char *string) { GLint value; enum wined3d_gl_resource_type type; - for (type = 0; type < ARRAY_SIZE(format->flags); ++type) + for (type = 0; type < ARRAY_SIZE(format->f.flags); ++type) { gl_info->gl_ops.ext.p_glGetInternalformativ(wined3d_gl_type_to_enum(type), internal, pname, 1, &value); if (value == GL_FULL_SUPPORT) { - TRACE("Format %s supports %s, resource type %u.\n", debug_d3dformat(format->id), string, type); - format->flags[type] |= flag; + TRACE("Format %s supports %s, resource type %u.\n", debug_d3dformat(format->f.id), string, type); + format->f.flags[type] |= flag; } else { - TRACE("Format %s doesn't support %s, resource type %u.\n", debug_d3dformat(format->id), string, type); - format->flags[type] &= ~flag; + TRACE("Format %s doesn't support %s, resource type %u.\n", debug_d3dformat(format->f.id), string, type); + format->f.flags[type] &= ~flag; } } } @@ -2740,56 +2745,56 @@ static void init_format_fbo_compat_info(const struct wined3d_adapter *adapter, { for (i = 0; i < WINED3D_FORMAT_COUNT; ++i) { - struct wined3d_format *format = get_format_by_idx(adapter, i); + struct wined3d_format_gl *format = get_format_gl_by_idx(adapter, i); BOOL fallback_fmt_used = FALSE, regular_fmt_used = FALSE; - GLenum rt_internal = format->rtInternal; + GLenum rt_internal = format->rt_internal; GLint value; - if (!format->glInternal) + if (!format->internal) continue; - for (type = 0; type < ARRAY_SIZE(format->flags); ++type) + for (type = 0; type < ARRAY_SIZE(format->f.flags); ++type) { gl_info->gl_ops.ext.p_glGetInternalformativ(wined3d_gl_type_to_enum(type), - format->glInternal, GL_FRAMEBUFFER_RENDERABLE, 1, &value); + format->internal, GL_FRAMEBUFFER_RENDERABLE, 1, &value); if (value == GL_FULL_SUPPORT) { TRACE("Format %s is supported as FBO color attachment, resource type %u.\n", - debug_d3dformat(format->id), type); - format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE; - format->rtInternal = format->glInternal; + debug_d3dformat(format->f.id), type); + format->f.flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE; + format->rt_internal = format->internal; regular_fmt_used = TRUE; gl_info->gl_ops.ext.p_glGetInternalformativ(wined3d_gl_type_to_enum(type), - format->glInternal, GL_FRAMEBUFFER_BLEND, 1, &value); + format->internal, GL_FRAMEBUFFER_BLEND, 1, &value); if (value == GL_FULL_SUPPORT) { TRACE("Format %s supports post-pixelshader blending, resource type %u.\n", - debug_d3dformat(format->id), type); - format->flags[type] |= WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING; + debug_d3dformat(format->f.id), type); + format->f.flags[type] |= WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING; } else { TRACE("Format %s doesn't support post-pixelshader blending, resource typed %u.\n", - debug_d3dformat(format->id), type); - format->flags[type] &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING; + debug_d3dformat(format->f.id), type); + format->f.flags[type] &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING; } } else { if (!rt_internal) { - if (format->flags[type] & WINED3DFMT_FLAG_RENDERTARGET) + if (format->f.flags[type] & WINED3DFMT_FLAG_RENDERTARGET) { WARN("Format %s with rendertarget flag is not supported as FBO color attachment" " and no fallback specified, resource type %u.\n", - debug_d3dformat(format->id), type); - format->flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET; + debug_d3dformat(format->f.id), type); + format->f.flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET; } else TRACE("Format %s is not supported as FBO color attachment," - " resource type %u.\n", debug_d3dformat(format->id), type); - format->rtInternal = format->glInternal; + " resource type %u.\n", debug_d3dformat(format->f.id), type); + format->rt_internal = format->internal; } else { @@ -2798,46 +2803,46 @@ static void init_format_fbo_compat_info(const struct wined3d_adapter *adapter, if (value == GL_FULL_SUPPORT) { TRACE("Format %s rtInternal format is supported as FBO color attachment," - " resource type %u.\n", debug_d3dformat(format->id), type); + " resource type %u.\n", debug_d3dformat(format->f.id), type); fallback_fmt_used = TRUE; } else { WARN("Format %s rtInternal format is not supported as FBO color attachment," - " resource type %u.\n", debug_d3dformat(format->id), type); - format->flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET; + " resource type %u.\n", debug_d3dformat(format->f.id), type); + format->f.flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET; } } } - if (format->glInternal != format->glGammaInternal) + if (format->internal != format->srgb_internal) { gl_info->gl_ops.ext.p_glGetInternalformativ(wined3d_gl_type_to_enum(type), - format->glGammaInternal, GL_FRAMEBUFFER_RENDERABLE, 1, &value); + format->srgb_internal, GL_FRAMEBUFFER_RENDERABLE, 1, &value); if (value == GL_FULL_SUPPORT) { TRACE("Format %s's sRGB format is FBO attachable, resource type %u.\n", - debug_d3dformat(format->id), type); - format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB; + debug_d3dformat(format->f.id), type); + format->f.flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB; if (gl_info->supported[EXT_TEXTURE_SRGB_DECODE]) - format->glInternal = format->glGammaInternal; + format->internal = format->srgb_internal; } else { WARN("Format %s's sRGB format is not FBO attachable, resource type %u.\n", - debug_d3dformat(format->id), type); - format_clear_flag(format, WINED3DFMT_FLAG_SRGB_WRITE); + debug_d3dformat(format->f.id), type); + format_clear_flag(&format->f, WINED3DFMT_FLAG_SRGB_WRITE); } } - else if (format->flags[type] & WINED3DFMT_FLAG_FBO_ATTACHABLE) - format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB; + else if (format->f.flags[type] & WINED3DFMT_FLAG_FBO_ATTACHABLE) + format->f.flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB; } if (fallback_fmt_used && regular_fmt_used) { FIXME("Format %s needs different render target formats for different resource types.\n", - debug_d3dformat(format->id)); - format_clear_flag(format, WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_FBO_ATTACHABLE + debug_d3dformat(format->f.id)); + format_clear_flag(&format->f, WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_FBO_ATTACHABLE | WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING); } } @@ -2854,25 +2859,26 @@ static void init_format_fbo_compat_info(const struct wined3d_adapter *adapter, for (i = 0; i < WINED3D_FORMAT_COUNT; ++i) { - struct wined3d_format *format = get_format_by_idx(adapter, i); + struct wined3d_format_gl *format = get_format_gl_by_idx(adapter, i); - if (!format->glInternal) continue; + if (!format->internal) + continue; - if (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_COMPRESSED) + if (format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_COMPRESSED) { TRACE("Skipping format %s because it's a compressed format.\n", - debug_d3dformat(format->id)); + debug_d3dformat(format->f.id)); continue; } if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) { - TRACE("Checking if format %s is supported as FBO color attachment...\n", debug_d3dformat(format->id)); + TRACE("Checking if format %s is supported as FBO color attachment...\n", debug_d3dformat(format->f.id)); check_fbo_compat(ctx, format); } else { - format->rtInternal = format->glInternal; + format->rt_internal = format->internal; } } @@ -2995,9 +3001,9 @@ static void query_view_class(struct wined3d_format_gl *format) { GLenum internal_view_class, gamma_view_class, rt_view_class; - internal_view_class = lookup_gl_view_class(format->f.glInternal); - gamma_view_class = lookup_gl_view_class(format->f.glGammaInternal); - rt_view_class = lookup_gl_view_class(format->f.rtInternal); + internal_view_class = lookup_gl_view_class(format->internal); + gamma_view_class = lookup_gl_view_class(format->srgb_internal); + rt_view_class = lookup_gl_view_class(format->rt_internal); if (internal_view_class == gamma_view_class || gamma_view_class == rt_view_class) { @@ -3012,7 +3018,7 @@ static void query_view_class(struct wined3d_format_gl *format) } static void query_internal_format(struct wined3d_adapter *adapter, - struct wined3d_format *format, const struct wined3d_format_texture_info *texture_info, + struct wined3d_format_gl *format, const struct wined3d_format_texture_info *texture_info, struct wined3d_gl_info *gl_info, BOOL srgb_write_supported, BOOL srgb_format) { GLint count, multisample_types[8]; @@ -3021,105 +3027,106 @@ static void query_internal_format(struct wined3d_adapter *adapter, if (gl_info->supported[ARB_INTERNALFORMAT_QUERY2]) { - query_format_flag(gl_info, format, format->glInternal, GL_VERTEX_TEXTURE, + query_format_flag(gl_info, format, format->internal, GL_VERTEX_TEXTURE, WINED3DFMT_FLAG_VTF, "vertex texture usage"); - query_format_flag(gl_info, format, format->glInternal, GL_FILTER, + query_format_flag(gl_info, format, format->internal, GL_FILTER, WINED3DFMT_FLAG_FILTERING, "filtering"); - if (srgb_format || format->glGammaInternal != format->glInternal) + if (srgb_format || format->srgb_internal != format->internal) { - query_format_flag(gl_info, format, format->glGammaInternal, GL_SRGB_READ, + query_format_flag(gl_info, format, format->srgb_internal, GL_SRGB_READ, WINED3DFMT_FLAG_SRGB_READ, "sRGB read"); if (srgb_write_supported) - query_format_flag(gl_info, format, format->glGammaInternal, GL_SRGB_WRITE, + query_format_flag(gl_info, format, format->srgb_internal, GL_SRGB_WRITE, WINED3DFMT_FLAG_SRGB_WRITE, "sRGB write"); else - format_clear_flag(format, WINED3DFMT_FLAG_SRGB_WRITE); + format_clear_flag(&format->f, WINED3DFMT_FLAG_SRGB_WRITE); - if (!(format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & (WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE))) - format->glGammaInternal = format->glInternal; + if (!(format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] + & (WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE))) + format->srgb_internal = format->internal; else if (wined3d_settings.offscreen_rendering_mode != ORM_FBO && gl_info->supported[EXT_TEXTURE_SRGB_DECODE]) - format->glInternal = format->glGammaInternal; + format->internal = format->srgb_internal; } } else { if (!gl_info->limits.samplers[WINED3D_SHADER_TYPE_VERTEX]) - format_clear_flag(format, WINED3DFMT_FLAG_VTF); + format_clear_flag(&format->f, WINED3DFMT_FLAG_VTF); if (!(gl_info->quirks & WINED3D_QUIRK_LIMITED_TEX_FILTERING)) - format_set_flag(format, WINED3DFMT_FLAG_FILTERING); - else if (format->id != WINED3DFMT_R32G32B32A32_FLOAT && format->id != WINED3DFMT_R32_FLOAT) - format_clear_flag(format, WINED3DFMT_FLAG_VTF); + format_set_flag(&format->f, WINED3DFMT_FLAG_FILTERING); + else if (format->f.id != WINED3DFMT_R32G32B32A32_FLOAT && format->f.id != WINED3DFMT_R32_FLOAT) + format_clear_flag(&format->f, WINED3DFMT_FLAG_VTF); - if (srgb_format || format->glGammaInternal != format->glInternal) + if (srgb_format || format->srgb_internal != format->internal) { /* Filter sRGB capabilities if EXT_texture_sRGB is not supported. */ if (!gl_info->supported[EXT_TEXTURE_SRGB]) { - format->glGammaInternal = format->glInternal; - format_clear_flag(format, WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE); + format->srgb_internal = format->internal; + format_clear_flag(&format->f, WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE); } else if (wined3d_settings.offscreen_rendering_mode != ORM_FBO && gl_info->supported[EXT_TEXTURE_SRGB_DECODE]) { - format->glInternal = format->glGammaInternal; + format->internal = format->srgb_internal; } } - if ((format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_SRGB_WRITE) && !srgb_write_supported) - format_clear_flag(format, WINED3DFMT_FLAG_SRGB_WRITE); + if ((format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_SRGB_WRITE) && !srgb_write_supported) + format_clear_flag(&format->f, WINED3DFMT_FLAG_SRGB_WRITE); if (!gl_info->supported[ARB_DEPTH_TEXTURE] && texture_info->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) { - format->flags[WINED3D_GL_RES_TYPE_TEX_1D] &= ~WINED3DFMT_FLAG_TEXTURE; - format->flags[WINED3D_GL_RES_TYPE_TEX_2D] &= ~WINED3DFMT_FLAG_TEXTURE; - format->flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE; - format->flags[WINED3D_GL_RES_TYPE_TEX_CUBE] &= ~WINED3DFMT_FLAG_TEXTURE; - format->flags[WINED3D_GL_RES_TYPE_TEX_RECT] &= ~WINED3DFMT_FLAG_TEXTURE; + format->f.flags[WINED3D_GL_RES_TYPE_TEX_1D] &= ~WINED3DFMT_FLAG_TEXTURE; + format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] &= ~WINED3DFMT_FLAG_TEXTURE; + format->f.flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE; + format->f.flags[WINED3D_GL_RES_TYPE_TEX_CUBE] &= ~WINED3DFMT_FLAG_TEXTURE; + format->f.flags[WINED3D_GL_RES_TYPE_TEX_RECT] &= ~WINED3DFMT_FLAG_TEXTURE; } } - query_view_class(wined3d_format_gl_mutable(format)); + query_view_class(format); - if (format->glInternal && format->flags[WINED3D_GL_RES_TYPE_RB] + if (format->internal && format->f.flags[WINED3D_GL_RES_TYPE_RB] & (WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) { if (gl_info->supported[ARB_INTERNALFORMAT_QUERY]) { target = gl_info->supported[ARB_TEXTURE_MULTISAMPLE] ? GL_TEXTURE_2D_MULTISAMPLE : GL_RENDERBUFFER; count = 0; - GL_EXTCALL(glGetInternalformativ(target, format->glInternal, + GL_EXTCALL(glGetInternalformativ(target, format->internal, GL_NUM_SAMPLE_COUNTS, 1, &count)); if (count > ARRAY_SIZE(multisample_types)) FIXME("Unexpectedly high number of multisample types %d.\n", count); count = min(count, ARRAY_SIZE(multisample_types)); - GL_EXTCALL(glGetInternalformativ(target, format->glInternal, + GL_EXTCALL(glGetInternalformativ(target, format->internal, GL_SAMPLES, count, multisample_types)); checkGLcall("query sample counts"); for (i = 0; i < count; ++i) { - if (multisample_types[i] > sizeof(format->multisample_types) * CHAR_BIT) + if (multisample_types[i] > sizeof(format->f.multisample_types) * CHAR_BIT) continue; - format->multisample_types |= 1u << (multisample_types[i] - 1); + format->f.multisample_types |= 1u << (multisample_types[i] - 1); } } else { max_log2 = wined3d_log2i(min(gl_info->limits.samples, - sizeof(format->multisample_types) * CHAR_BIT)); + sizeof(format->f.multisample_types) * CHAR_BIT)); for (i = 1; i <= max_log2; ++i) - format->multisample_types |= 1u << ((1u << i) - 1); + format->f.multisample_types |= 1u << ((1u << i) - 1); } } } static BOOL init_format_texture_info(struct wined3d_adapter *adapter, struct wined3d_gl_info *gl_info) { - struct wined3d_format *format, *srgb_format; + struct wined3d_format_gl *format, *srgb_format; struct fragment_caps fragment_caps; struct shader_caps shader_caps; unsigned int i, j; @@ -3132,7 +3139,7 @@ static BOOL init_format_texture_info(struct wined3d_adapter *adapter, struct win for (i = 0; i < ARRAY_SIZE(format_texture_info); ++i) { - if (!(format = get_format_internal(adapter, format_texture_info[i].id))) + if (!(format = get_format_gl_internal(adapter, format_texture_info[i].id))) return FALSE; if (!gl_info->supported[format_texture_info[i].extension]) @@ -3141,62 +3148,62 @@ static BOOL init_format_texture_info(struct wined3d_adapter *adapter, struct win /* ARB_texture_rg defines floating point formats, but only if * ARB_texture_float is also supported. */ if (!gl_info->supported[ARB_TEXTURE_FLOAT] - && (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_FLOAT)) + && (format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_FLOAT)) continue; /* ARB_texture_rg defines integer formats if EXT_texture_integer is also supported. */ if (!gl_info->supported[EXT_TEXTURE_INTEGER] - && (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_INTEGER)) + && (format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_INTEGER)) continue; - format->glInternal = format_texture_info[i].gl_internal; - format->glGammaInternal = format_texture_info[i].gl_srgb_internal; - format->rtInternal = format_texture_info[i].gl_rt_internal; - format->glFormat = format_texture_info[i].gl_format; - format->glType = format_texture_info[i].gl_type; - format->color_fixup = COLOR_FIXUP_IDENTITY; - format->height_scale.numerator = 1; - format->height_scale.denominator = 1; + format->internal = format_texture_info[i].gl_internal; + format->srgb_internal = format_texture_info[i].gl_srgb_internal; + format->rt_internal = format_texture_info[i].gl_rt_internal; + format->format = format_texture_info[i].gl_format; + format->type = format_texture_info[i].gl_type; + format->f.color_fixup = COLOR_FIXUP_IDENTITY; + format->f.height_scale.numerator = 1; + format->f.height_scale.denominator = 1; - format->flags[WINED3D_GL_RES_TYPE_TEX_1D] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; - format->flags[WINED3D_GL_RES_TYPE_TEX_2D] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; - format->flags[WINED3D_GL_RES_TYPE_BUFFER] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; + format->f.flags[WINED3D_GL_RES_TYPE_TEX_1D] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; + format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; + format->f.flags[WINED3D_GL_RES_TYPE_BUFFER] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; /* GL_ARB_depth_texture does not support 3D textures. It also says "cube textures are * problematic", but doesn't explicitly mandate that an error is generated. */ if (gl_info->supported[EXT_TEXTURE3D] && !(format_texture_info[i].flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))) - format->flags[WINED3D_GL_RES_TYPE_TEX_3D] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; + format->f.flags[WINED3D_GL_RES_TYPE_TEX_3D] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; if (gl_info->supported[ARB_TEXTURE_CUBE_MAP]) - format->flags[WINED3D_GL_RES_TYPE_TEX_CUBE] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; + format->f.flags[WINED3D_GL_RES_TYPE_TEX_CUBE] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; if (gl_info->supported[ARB_TEXTURE_RECTANGLE]) - format->flags[WINED3D_GL_RES_TYPE_TEX_RECT] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; + format->f.flags[WINED3D_GL_RES_TYPE_TEX_RECT] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; - format->flags[WINED3D_GL_RES_TYPE_RB] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; - format->flags[WINED3D_GL_RES_TYPE_RB] &= ~WINED3DFMT_FLAG_TEXTURE; + format->f.flags[WINED3D_GL_RES_TYPE_RB] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; + format->f.flags[WINED3D_GL_RES_TYPE_RB] &= ~WINED3DFMT_FLAG_TEXTURE; - if (format->glGammaInternal != format->glInternal + if (format->srgb_internal != format->internal && !(adapter->d3d_info.wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL)) { - format->glGammaInternal = format->glInternal; - format_clear_flag(format, WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE); + format->srgb_internal = format->internal; + format_clear_flag(&format->f, WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE); } query_internal_format(adapter, format, &format_texture_info[i], gl_info, srgb_write, FALSE); /* Texture conversion stuff */ - format->conv_byte_count = format_texture_info[i].conv_byte_count; - format->upload = format_texture_info[i].upload; - format->download = format_texture_info[i].download; + format->f.conv_byte_count = format_texture_info[i].conv_byte_count; + format->f.upload = format_texture_info[i].upload; + format->f.download = format_texture_info[i].download; srgb_format = NULL; for (j = 0; j < ARRAY_SIZE(format_srgb_info); ++j) { - if (format_srgb_info[j].base_format_id == format->id) + if (format_srgb_info[j].base_format_id == format->f.id) { - if (!(srgb_format = get_format_internal(adapter, format_srgb_info[j].srgb_format_id))) + if (!(srgb_format = get_format_gl_internal(adapter, format_srgb_info[j].srgb_format_id))) return FALSE; break; } @@ -3204,14 +3211,14 @@ static BOOL init_format_texture_info(struct wined3d_adapter *adapter, struct win if (!srgb_format) continue; - copy_format(adapter, srgb_format, format); + copy_format(adapter, &srgb_format->f, &format->f); if (gl_info->supported[EXT_TEXTURE_SRGB] && !(adapter->d3d_info.wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL)) { - srgb_format->glInternal = format_texture_info[i].gl_srgb_internal; - srgb_format->glGammaInternal = format_texture_info[i].gl_srgb_internal; - format_set_flag(srgb_format, WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE); + srgb_format->internal = format_texture_info[i].gl_srgb_internal; + srgb_format->srgb_internal = format_texture_info[i].gl_srgb_internal; + format_set_flag(&srgb_format->f, WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE); query_internal_format(adapter, srgb_format, &format_texture_info[i], gl_info, srgb_write, TRUE); } } @@ -3335,7 +3342,7 @@ static void init_format_filter_info(struct wined3d_adapter *adapter, struct wined3d_gl_info *gl_info) { enum wined3d_pci_vendor vendor = adapter->driver_info.vendor; - struct wined3d_format *format; + struct wined3d_format_gl *format; unsigned int i; static const enum wined3d_format_id fmts16[] = { @@ -3373,8 +3380,8 @@ static void init_format_filter_info(struct wined3d_adapter *adapter, { for (i = 0; i < ARRAY_SIZE(fmts16); ++i) { - format = get_format_internal(adapter, fmts16[i]); - format_set_flag(format, WINED3DFMT_FLAG_FILTERING); + format = get_format_gl_internal(adapter, fmts16[i]); + format_set_flag(&format->f, WINED3DFMT_FLAG_FILTERING); } } return; @@ -3382,19 +3389,19 @@ static void init_format_filter_info(struct wined3d_adapter *adapter, for (i = 0; i < ARRAY_SIZE(fmts16); ++i) { - format = get_format_internal(adapter, fmts16[i]); - if (!format->glInternal) + format = get_format_gl_internal(adapter, fmts16[i]); + if (!format->internal) continue; /* Not supported by GL */ - filtered = check_filter(gl_info, format->glInternal); + filtered = check_filter(gl_info, format->internal); if (filtered) { - TRACE("Format %s supports filtering.\n", debug_d3dformat(format->id)); - format_set_flag(format, WINED3DFMT_FLAG_FILTERING); + TRACE("Format %s supports filtering.\n", debug_d3dformat(format->f.id)); + format_set_flag(&format->f, WINED3DFMT_FLAG_FILTERING); } else { - TRACE("Format %s does not support filtering.\n", debug_d3dformat(format->id)); + TRACE("Format %s does not support filtering.\n", debug_d3dformat(format->f.id)); } } } @@ -3455,7 +3462,7 @@ static struct color_fixup_desc create_color_fixup_desc_from_string(const char *s static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_gl_info *gl_info) { const struct wined3d_d3d_info *d3d_info = &adapter->d3d_info; - struct wined3d_format *format; + struct wined3d_format_gl *format; BOOL use_legacy_fixups; unsigned int i; @@ -3527,79 +3534,79 @@ static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_ if (!gl_info->supported[fixups[i].extension]) continue; - format = get_format_internal(adapter, fixups[i].id); - format->color_fixup = create_color_fixup_desc_from_string(fixups[i].fixup); + format = get_format_gl_internal(adapter, fixups[i].id); + format->f.color_fixup = create_color_fixup_desc_from_string(fixups[i].fixup); } if (!gl_info->supported[APPLE_YCBCR_422] && (gl_info->supported[ARB_FRAGMENT_PROGRAM] || (gl_info->supported[ARB_FRAGMENT_SHADER] && gl_info->supported[ARB_VERTEX_SHADER]))) { - format = get_format_internal(adapter, WINED3DFMT_YUY2); - format->color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YUY2); + format = get_format_gl_internal(adapter, WINED3DFMT_YUY2); + format->f.color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YUY2); - format = get_format_internal(adapter, WINED3DFMT_UYVY); - format->color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_UYVY); + format = get_format_gl_internal(adapter, WINED3DFMT_UYVY); + format->f.color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_UYVY); } else if (!gl_info->supported[APPLE_YCBCR_422] && (!gl_info->supported[ARB_FRAGMENT_PROGRAM] && (!gl_info->supported[ARB_FRAGMENT_SHADER] || !gl_info->supported[ARB_VERTEX_SHADER]))) { - format = get_format_internal(adapter, WINED3DFMT_YUY2); - format_clear_flag(format, WINED3DFMT_FLAG_BLIT); - format->glInternal = 0; + format = get_format_gl_internal(adapter, WINED3DFMT_YUY2); + format_clear_flag(&format->f, WINED3DFMT_FLAG_BLIT); + format->internal = 0; - format = get_format_internal(adapter, WINED3DFMT_UYVY); - format_clear_flag(format, WINED3DFMT_FLAG_BLIT); - format->glInternal = 0; + format = get_format_gl_internal(adapter, WINED3DFMT_UYVY); + format_clear_flag(&format->f, WINED3DFMT_FLAG_BLIT); + format->internal = 0; } if (gl_info->supported[ARB_FRAGMENT_PROGRAM] || (gl_info->supported[ARB_FRAGMENT_SHADER] && gl_info->supported[ARB_VERTEX_SHADER])) { - format = get_format_internal(adapter, WINED3DFMT_YV12); - format_set_flag(format, WINED3DFMT_FLAG_HEIGHT_SCALE); - format->height_scale.numerator = 3; - format->height_scale.denominator = 2; - format->color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YV12); + format = get_format_gl_internal(adapter, WINED3DFMT_YV12); + format_set_flag(&format->f, WINED3DFMT_FLAG_HEIGHT_SCALE); + format->f.height_scale.numerator = 3; + format->f.height_scale.denominator = 2; + format->f.color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YV12); - format = get_format_internal(adapter, WINED3DFMT_NV12); - format_set_flag(format, WINED3DFMT_FLAG_HEIGHT_SCALE); - format->height_scale.numerator = 3; - format->height_scale.denominator = 2; - format->color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_NV12); + format = get_format_gl_internal(adapter, WINED3DFMT_NV12); + format_set_flag(&format->f, WINED3DFMT_FLAG_HEIGHT_SCALE); + format->f.height_scale.numerator = 3; + format->f.height_scale.denominator = 2; + format->f.color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_NV12); } else { - format = get_format_internal(adapter, WINED3DFMT_YV12); - format_clear_flag(format, WINED3DFMT_FLAG_BLIT); - format->glInternal = 0; + format = get_format_gl_internal(adapter, WINED3DFMT_YV12); + format_clear_flag(&format->f, WINED3DFMT_FLAG_BLIT); + format->internal = 0; - format = get_format_internal(adapter, WINED3DFMT_NV12); - format_clear_flag(format, WINED3DFMT_FLAG_BLIT); - format->glInternal = 0; + format = get_format_gl_internal(adapter, WINED3DFMT_NV12); + format_clear_flag(&format->f, WINED3DFMT_FLAG_BLIT); + format->internal = 0; } if (gl_info->supported[ARB_FRAGMENT_PROGRAM] || gl_info->supported[ARB_FRAGMENT_SHADER]) { - format = get_format_internal(adapter, WINED3DFMT_P8_UINT); - format->color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_P8); + format = get_format_gl_internal(adapter, WINED3DFMT_P8_UINT); + format->f.color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_P8); } if (!gl_info->supported[ARB_HALF_FLOAT_PIXEL]) { - format = get_format_internal(adapter, WINED3DFMT_R16_FLOAT); - format_clear_flag(format, WINED3DFMT_FLAG_TEXTURE); + format = get_format_gl_internal(adapter, WINED3DFMT_R16_FLOAT); + format_clear_flag(&format->f, WINED3DFMT_FLAG_TEXTURE); - format = get_format_internal(adapter, WINED3DFMT_R16G16_FLOAT); - format_clear_flag(format, WINED3DFMT_FLAG_TEXTURE); + format = get_format_gl_internal(adapter, WINED3DFMT_R16G16_FLOAT); + format_clear_flag(&format->f, WINED3DFMT_FLAG_TEXTURE); - format = get_format_internal(adapter, WINED3DFMT_R16G16B16A16_FLOAT); - format_clear_flag(format, WINED3DFMT_FLAG_TEXTURE); + format = get_format_gl_internal(adapter, WINED3DFMT_R16G16B16A16_FLOAT); + format_clear_flag(&format->f, WINED3DFMT_FLAG_TEXTURE); } if (gl_info->quirks & WINED3D_QUIRK_BROKEN_RGBA16) { - format = get_format_internal(adapter, WINED3DFMT_R16G16B16A16_UNORM); - format_clear_flag(format, WINED3DFMT_FLAG_TEXTURE); + format = get_format_gl_internal(adapter, WINED3DFMT_R16G16B16A16_UNORM); + format_clear_flag(&format->f, WINED3DFMT_FLAG_TEXTURE); } /* ATI instancing hack: Although ATI cards do not support Shader Model @@ -3617,8 +3624,8 @@ static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_ /* FIXME: This should just check the shader backend caps. */ if (gl_info->supported[ARB_VERTEX_PROGRAM] || gl_info->supported[ARB_VERTEX_SHADER]) { - format = get_format_internal(adapter, WINED3DFMT_INST); - format_set_flag(format, WINED3DFMT_FLAG_TEXTURE); + format = get_format_gl_internal(adapter, WINED3DFMT_INST); + format_set_flag(&format->f, WINED3DFMT_FLAG_TEXTURE); } /* Depth bound test. To query if the card supports it CheckDeviceFormat() @@ -3629,8 +3636,8 @@ static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_ * value. */ if (gl_info->supported[EXT_DEPTH_BOUNDS_TEST]) { - format = get_format_internal(adapter, WINED3DFMT_NVDB); - format_set_flag(format, WINED3DFMT_FLAG_TEXTURE); + format = get_format_gl_internal(adapter, WINED3DFMT_NVDB); + format_set_flag(&format->f, WINED3DFMT_FLAG_TEXTURE); } /* RESZ aka AMD DX9-level hack for multisampled depth buffer resolve. You query for RESZ @@ -3638,27 +3645,27 @@ static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_ * RENDERTARGET usage. */ if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT]) { - format = get_format_internal(adapter, WINED3DFMT_RESZ); - format_set_flag(format, WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET); + format = get_format_gl_internal(adapter, WINED3DFMT_RESZ); + format_set_flag(&format->f, WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET); } for (i = 0; i < WINED3D_FORMAT_COUNT; ++i) { - struct wined3d_format *format = get_format_by_idx(adapter, i); + format = get_format_gl_by_idx(adapter, i); - if (!(format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_TEXTURE)) + if (!(format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_TEXTURE)) continue; - if (is_identity_fixup(format->color_fixup)) + if (is_identity_fixup(format->f.color_fixup)) continue; TRACE("Checking support for fixup:\n"); - dump_color_fixup_desc(format->color_fixup); - if (!adapter->shader_backend->shader_color_fixup_supported(format->color_fixup) - || !adapter->fragment_pipe->color_fixup_supported(format->color_fixup)) + dump_color_fixup_desc(format->f.color_fixup); + if (!adapter->shader_backend->shader_color_fixup_supported(format->f.color_fixup) + || !adapter->fragment_pipe->color_fixup_supported(format->f.color_fixup)) { TRACE("[FAILED]\n"); - format_clear_flag(format, WINED3DFMT_FLAG_TEXTURE); + format_clear_flag(&format->f, WINED3DFMT_FLAG_TEXTURE); } else { @@ -3668,18 +3675,18 @@ static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_ /* These formats are not supported for 3D textures. See also * WINED3DFMT_FLAG_DECOMPRESS. */ - format = get_format_internal(adapter, WINED3DFMT_ATI1N); - format->flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE; - format = get_format_internal(adapter, WINED3DFMT_ATI2N); - format->flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE; - format = get_format_internal(adapter, WINED3DFMT_BC4_UNORM); - format->flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE; - format = get_format_internal(adapter, WINED3DFMT_BC4_SNORM); - format->flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE; - format = get_format_internal(adapter, WINED3DFMT_BC5_UNORM); - format->flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE; - format = get_format_internal(adapter, WINED3DFMT_BC5_SNORM); - format->flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE; + format = get_format_gl_internal(adapter, WINED3DFMT_ATI1N); + format->f.flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE; + format = get_format_gl_internal(adapter, WINED3DFMT_ATI2N); + format->f.flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE; + format = get_format_gl_internal(adapter, WINED3DFMT_BC4_UNORM); + format->f.flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE; + format = get_format_gl_internal(adapter, WINED3DFMT_BC4_SNORM); + format->f.flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE; + format = get_format_gl_internal(adapter, WINED3DFMT_BC5_UNORM); + format->f.flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE; + format = get_format_gl_internal(adapter, WINED3DFMT_BC5_SNORM); + format->f.flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE; } static BOOL init_format_vertex_info(const struct wined3d_adapter *adapter, @@ -3936,22 +3943,22 @@ static void init_format_depth_bias_scale(struct wined3d_adapter *adapter, for (i = 0; i < WINED3D_FORMAT_COUNT; ++i) { - struct wined3d_format *format = get_format_by_idx(adapter, i); + struct wined3d_format_gl *format = get_format_gl_by_idx(adapter, i); - if (format->flags[WINED3D_GL_RES_TYPE_RB] & WINED3DFMT_FLAG_DEPTH) + if (format->f.flags[WINED3D_GL_RES_TYPE_RB] & WINED3DFMT_FLAG_DEPTH) { - TRACE("Testing depth bias scale for format %s.\n", debug_d3dformat(format->id)); - format->depth_bias_scale = wined3d_adapter_find_polyoffset_scale(ctx, format->glInternal); + TRACE("Testing depth bias scale for format %s.\n", debug_d3dformat(format->f.id)); + format->f.depth_bias_scale = wined3d_adapter_find_polyoffset_scale(ctx, format->internal); if (!(d3d_info->wined3d_creation_flags & WINED3D_NORMALIZED_DEPTH_BIAS)) { /* The single-precision binary floating-point format has * a significand precision of 24 bits. */ - if (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_FLOAT) - format->depth_bias_scale /= 1u << 24; + if (format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_FLOAT) + format->f.depth_bias_scale /= 1u << 24; else - format->depth_bias_scale /= 1u << format->depth_size; + format->f.depth_bias_scale /= 1u << format->f.depth_size; } } } diff --git a/dlls/wined3d/view.c b/dlls/wined3d/view.c index dedb9fc8047..ff284684089 100644 --- a/dlls/wined3d/view.c +++ b/dlls/wined3d/view.c @@ -169,11 +169,13 @@ static void create_texture_view(struct wined3d_gl_view *view, GLenum view_target const struct wined3d_view_desc *desc, struct wined3d_texture *texture, const struct wined3d_format *view_format) { + const struct wined3d_format_gl *view_format_gl; unsigned int level_idx, layer_idx, layer_count; const struct wined3d_gl_info *gl_info; struct wined3d_context *context; GLuint texture_name; + view_format_gl = wined3d_format_gl(view_format); view->target = view_target; context = context_acquire(texture->resource.device, NULL, 0); @@ -201,11 +203,11 @@ static void create_texture_view(struct wined3d_gl_view *view, GLenum view_target } gl_info->gl_ops.gl.p_glGenTextures(1, &view->name); - GL_EXTCALL(glTextureView(view->name, view->target, texture_name, view_format->glInternal, + GL_EXTCALL(glTextureView(view->name, view->target, texture_name, view_format_gl->internal, level_idx, desc->u.texture.level_count, layer_idx, layer_count)); checkGLcall("create texture view"); - if (is_stencil_view_format(view_format)) + if (is_stencil_view_format(&view_format_gl->f)) { static const GLint swizzle[] = {GL_ZERO, GL_RED, GL_ZERO, GL_ZERO}; @@ -233,6 +235,7 @@ static void create_buffer_texture(struct wined3d_gl_view *view, struct wined3d_c unsigned int offset, unsigned int size) { const struct wined3d_gl_info *gl_info = context->gl_info; + const struct wined3d_format_gl *view_format_gl; if (!gl_info->supported[ARB_TEXTURE_BUFFER_OBJECT]) { @@ -247,6 +250,7 @@ static void create_buffer_texture(struct wined3d_gl_view *view, struct wined3d_c return; } + view_format_gl = wined3d_format_gl(view_format); wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_BUFFER); view->target = GL_TEXTURE_BUFFER; @@ -255,14 +259,14 @@ static void create_buffer_texture(struct wined3d_gl_view *view, struct wined3d_c context_bind_texture(context, GL_TEXTURE_BUFFER, view->name); if (gl_info->supported[ARB_TEXTURE_BUFFER_RANGE]) { - GL_EXTCALL(glTexBufferRange(GL_TEXTURE_BUFFER, view_format->glInternal, + GL_EXTCALL(glTexBufferRange(GL_TEXTURE_BUFFER, view_format_gl->internal, buffer->buffer_object, offset, size)); } else { if (offset || size != buffer->resource.size) FIXME("OpenGL implementation does not support ARB_texture_buffer_range.\n"); - GL_EXTCALL(glTexBuffer(GL_TEXTURE_BUFFER, view_format->glInternal, buffer->buffer_object)); + GL_EXTCALL(glTexBuffer(GL_TEXTURE_BUFFER, view_format_gl->internal, buffer->buffer_object)); } checkGLcall("Create buffer texture"); @@ -1006,7 +1010,7 @@ void wined3d_unordered_access_view_clear_uint(struct wined3d_unordered_access_vi const struct wined3d_uvec4 *clear_value, struct wined3d_context *context) { const struct wined3d_gl_info *gl_info = context->gl_info; - const struct wined3d_format *format; + const struct wined3d_format_gl *format; struct wined3d_resource *resource; struct wined3d_buffer *buffer; unsigned int offset, size; @@ -1024,12 +1028,12 @@ void wined3d_unordered_access_view_clear_uint(struct wined3d_unordered_access_vi return; } - format = view->format; - if (format->id != WINED3DFMT_R32_UINT && format->id != WINED3DFMT_R32_SINT - && format->id != WINED3DFMT_R32G32B32A32_UINT - && format->id != WINED3DFMT_R32G32B32A32_SINT) + format = wined3d_format_gl(view->format); + if (format->f.id != WINED3DFMT_R32_UINT && format->f.id != WINED3DFMT_R32_SINT + && format->f.id != WINED3DFMT_R32G32B32A32_UINT + && format->f.id != WINED3DFMT_R32G32B32A32_SINT) { - FIXME("Not implemented for format %s.\n", debug_d3dformat(format->id)); + FIXME("Not implemented for format %s.\n", debug_d3dformat(format->f.id)); return; } @@ -1037,10 +1041,10 @@ void wined3d_unordered_access_view_clear_uint(struct wined3d_unordered_access_vi wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_BUFFER); wined3d_unordered_access_view_invalidate_location(view, ~WINED3D_LOCATION_BUFFER); - get_buffer_view_range(buffer, &view->desc, format, &offset, &size); + get_buffer_view_range(buffer, &view->desc, &format->f, &offset, &size); context_bind_bo(context, buffer->buffer_type_hint, buffer->buffer_object); - GL_EXTCALL(glClearBufferSubData(buffer->buffer_type_hint, format->glInternal, - offset, size, format->glFormat, format->glType, clear_value)); + GL_EXTCALL(glClearBufferSubData(buffer->buffer_type_hint, format->internal, + offset, size, format->format, format->type, clear_value)); checkGLcall("clear unordered access view"); } diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index cec2cfff330..4c5d73f677e 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -4339,11 +4339,6 @@ struct wined3d_format enum wined3d_ffp_emit_idx emit_idx; - GLint glInternal; - GLint glGammaInternal; - GLint rtInternal; - GLint glFormat; - GLint glType; UINT conv_byte_count; DWORD multisample_types; unsigned int flags[WINED3D_GL_RES_TYPE_COUNT]; @@ -4387,6 +4382,12 @@ struct wined3d_format_gl GLenum vtx_type; GLint vtx_format; + GLint internal; + GLint srgb_internal; + GLint rt_internal; + GLint format; + GLint type; + GLenum view_class; }; -- 2.11.0

1 0

[PATCH 4/5] wined3d: Introduce WINED3DFMT_FLAG_BLIT.
by Henri Verbeet 21 Sep '18

21 Sep '18

To indicate whether a particular format can be used for "off-screen plain" surfaces. Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/directx.c | 40 +++------------------------- dlls/wined3d/utils.c | 59 +++++++++++++++++++++++++++++++++++++----- dlls/wined3d/wined3d_private.h | 2 ++ 3 files changed, 58 insertions(+), 43 deletions(-) diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 89684477e68..02ca3f6f04b 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -1474,41 +1474,9 @@ static BOOL CheckRenderTargetCapability(const struct wined3d_adapter *adapter, return FALSE; } -static BOOL wined3d_check_surface_capability(const struct wined3d_format *format, BOOL no3d) +static BOOL wined3d_check_surface_capability(const struct wined3d_format *format) { - if (no3d) - { - switch (format->id) - { - case WINED3DFMT_B8G8R8_UNORM: - TRACE("[FAILED] - Not enumerated on Windows.\n"); - return FALSE; - case WINED3DFMT_B8G8R8A8_UNORM: - case WINED3DFMT_B8G8R8X8_UNORM: - case WINED3DFMT_B5G6R5_UNORM: - case WINED3DFMT_B5G5R5X1_UNORM: - case WINED3DFMT_B5G5R5A1_UNORM: - case WINED3DFMT_B4G4R4A4_UNORM: - case WINED3DFMT_B2G3R3_UNORM: - case WINED3DFMT_A8_UNORM: - case WINED3DFMT_B2G3R3A8_UNORM: - case WINED3DFMT_B4G4R4X4_UNORM: - case WINED3DFMT_R10G10B10A2_UNORM: - case WINED3DFMT_R8G8B8A8_UNORM: - case WINED3DFMT_R8G8B8X8_UNORM: - case WINED3DFMT_R16G16_UNORM: - case WINED3DFMT_B10G10R10A2_UNORM: - case WINED3DFMT_R16G16B16A16_UNORM: - case WINED3DFMT_P8_UINT: - TRACE("[OK]\n"); - return TRUE; - default: - TRACE("[FAILED] - Not available on GDI surfaces.\n"); - return FALSE; - } - } - - if (format->glInternal) + if ((format->flags[WINED3D_GL_RES_TYPE_TEX_2D] | format->flags[WINED3D_GL_RES_TYPE_RB]) & WINED3DFMT_FLAG_BLIT) { TRACE("[OK]\n"); return TRUE; @@ -1589,7 +1557,7 @@ HRESULT CDECL wined3d_check_device_format(const struct wined3d *wined3d, UINT ad allowed_usage |= WINED3DUSAGE_QUERY_SRGBWRITE; if (!(usage & WINED3DUSAGE_TEXTURE)) { - if (!wined3d_check_surface_capability(format, wined3d->flags & WINED3D_NO3D)) + if (!wined3d_check_surface_capability(format)) { TRACE("[FAILED] - Not supported for plain surfaces.\n"); return WINED3DERR_NOTAVAILABLE; @@ -2490,7 +2458,7 @@ static BOOL wined3d_adapter_no3d_init(struct wined3d_adapter *adapter) adapter->vram_bytes_used = 0; TRACE("Emulating 0x%s bytes of video ram.\n", wine_dbgstr_longlong(adapter->vram_bytes)); - if (!wined3d_adapter_init_format_info(adapter, sizeof(struct wined3d_format))) + if (!wined3d_adapter_no3d_init_format_info(adapter)) return FALSE; adapter->vertex_pipe = &none_vertex_pipe; diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 8e9b6dfafd6..36694856081 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -3158,23 +3158,23 @@ static BOOL init_format_texture_info(struct wined3d_adapter *adapter, struct win format->height_scale.numerator = 1; format->height_scale.denominator = 1; - format->flags[WINED3D_GL_RES_TYPE_TEX_1D] |= format_texture_info[i].flags; - format->flags[WINED3D_GL_RES_TYPE_TEX_2D] |= format_texture_info[i].flags; - format->flags[WINED3D_GL_RES_TYPE_BUFFER] |= format_texture_info[i].flags; + format->flags[WINED3D_GL_RES_TYPE_TEX_1D] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; + format->flags[WINED3D_GL_RES_TYPE_TEX_2D] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; + format->flags[WINED3D_GL_RES_TYPE_BUFFER] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; /* GL_ARB_depth_texture does not support 3D textures. It also says "cube textures are * problematic", but doesn't explicitly mandate that an error is generated. */ if (gl_info->supported[EXT_TEXTURE3D] && !(format_texture_info[i].flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))) - format->flags[WINED3D_GL_RES_TYPE_TEX_3D] |= format_texture_info[i].flags; + format->flags[WINED3D_GL_RES_TYPE_TEX_3D] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; if (gl_info->supported[ARB_TEXTURE_CUBE_MAP]) - format->flags[WINED3D_GL_RES_TYPE_TEX_CUBE] |= format_texture_info[i].flags; + format->flags[WINED3D_GL_RES_TYPE_TEX_CUBE] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; if (gl_info->supported[ARB_TEXTURE_RECTANGLE]) - format->flags[WINED3D_GL_RES_TYPE_TEX_RECT] |= format_texture_info[i].flags; + format->flags[WINED3D_GL_RES_TYPE_TEX_RECT] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; - format->flags[WINED3D_GL_RES_TYPE_RB] |= format_texture_info[i].flags; + format->flags[WINED3D_GL_RES_TYPE_RB] |= format_texture_info[i].flags | WINED3DFMT_FLAG_BLIT; format->flags[WINED3D_GL_RES_TYPE_RB] &= ~WINED3DFMT_FLAG_TEXTURE; if (format->glGammaInternal != format->glInternal @@ -3544,9 +3544,11 @@ static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_ && (!gl_info->supported[ARB_FRAGMENT_SHADER] || !gl_info->supported[ARB_VERTEX_SHADER]))) { format = get_format_internal(adapter, WINED3DFMT_YUY2); + format_clear_flag(format, WINED3DFMT_FLAG_BLIT); format->glInternal = 0; format = get_format_internal(adapter, WINED3DFMT_UYVY); + format_clear_flag(format, WINED3DFMT_FLAG_BLIT); format->glInternal = 0; } @@ -3568,9 +3570,11 @@ static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_ else { format = get_format_internal(adapter, WINED3DFMT_YV12); + format_clear_flag(format, WINED3DFMT_FLAG_BLIT); format->glInternal = 0; format = get_format_internal(adapter, WINED3DFMT_NV12); + format_clear_flag(format, WINED3DFMT_FLAG_BLIT); format->glInternal = 0; } @@ -3979,6 +3983,47 @@ fail: return FALSE; } +BOOL wined3d_adapter_no3d_init_format_info(struct wined3d_adapter *adapter) +{ + struct wined3d_format *format; + unsigned int i; + + static const enum wined3d_format_id blit_formats[] = + { + WINED3DFMT_B8G8R8A8_UNORM, + WINED3DFMT_B8G8R8X8_UNORM, + WINED3DFMT_B5G6R5_UNORM, + WINED3DFMT_B5G5R5X1_UNORM, + WINED3DFMT_B5G5R5A1_UNORM, + WINED3DFMT_B4G4R4A4_UNORM, + WINED3DFMT_B2G3R3_UNORM, + WINED3DFMT_A8_UNORM, + WINED3DFMT_B2G3R3A8_UNORM, + WINED3DFMT_B4G4R4X4_UNORM, + WINED3DFMT_R10G10B10A2_UNORM, + WINED3DFMT_R8G8B8A8_UNORM, + WINED3DFMT_R8G8B8X8_UNORM, + WINED3DFMT_R16G16_UNORM, + WINED3DFMT_B10G10R10A2_UNORM, + WINED3DFMT_R16G16B16A16_UNORM, + WINED3DFMT_P8_UINT, + }; + + if (!wined3d_adapter_init_format_info(adapter, sizeof(struct wined3d_format))) + return FALSE; + + for (i = 0; i < ARRAY_SIZE(blit_formats); ++i) + { + if (!(format = get_format_internal(adapter, blit_formats[i]))) + return FALSE; + + format->flags[WINED3D_GL_RES_TYPE_TEX_2D] |= WINED3DFMT_FLAG_BLIT; + format->flags[WINED3D_GL_RES_TYPE_RB] |= WINED3DFMT_FLAG_BLIT; + } + + return TRUE; +} + /* Context activation is done by the caller. */ BOOL wined3d_adapter_gl_init_format_info(struct wined3d_adapter *adapter, struct wined3d_caps_gl_ctx *ctx) { diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index cb2f44212c4..cec2cfff330 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2695,6 +2695,7 @@ struct wined3d_caps_gl_ctx BOOL wined3d_adapter_init_format_info(struct wined3d_adapter *adapter, size_t format_size) DECLSPEC_HIDDEN; BOOL wined3d_adapter_gl_init_format_info(struct wined3d_adapter *adapter, struct wined3d_caps_gl_ctx *ctx) DECLSPEC_HIDDEN; +BOOL wined3d_adapter_no3d_init_format_info(struct wined3d_adapter *adapter) DECLSPEC_HIDDEN; UINT64 adapter_adjust_memory(struct wined3d_adapter *adapter, INT64 amount) DECLSPEC_HIDDEN; BOOL wined3d_caps_gl_ctx_test_viewport_subpixel_bits(struct wined3d_caps_gl_ctx *ctx) DECLSPEC_HIDDEN; @@ -4299,6 +4300,7 @@ extern enum wined3d_format_id pixelformat_for_depth(DWORD depth) DECLSPEC_HIDDEN #define WINED3DFMT_FLAG_GEN_MIPMAP 0x00400000 #define WINED3DFMT_FLAG_NORMALISED 0x00800000 #define WINED3DFMT_FLAG_VERTEX_ATTRIBUTE 0x01000000 +#define WINED3DFMT_FLAG_BLIT 0x02000000 struct wined3d_rational { -- 2.11.0

1 0

[PATCH 3/5] wined3d: Accept "renderer" in addition to "DirectDrawRenderer".
by Henri Verbeet 21 Sep '18

21 Sep '18

Even though the "gdi" renderer is mainly used for ddraw, wined3d itself has no knowledge of ddraw. Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/wined3d_main.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/dlls/wined3d/wined3d_main.c b/dlls/wined3d/wined3d_main.c index f8a84a17adb..3537a4884fe 100644 --- a/dlls/wined3d/wined3d_main.c +++ b/dlls/wined3d/wined3d_main.c @@ -307,7 +307,8 @@ static BOOL wined3d_dll_init(HINSTANCE hInstDLL) TRACE("Limiting PS shader model to %u.\n", wined3d_settings.max_sm_ps); if (!get_config_key_dword(hkey, appkey, "MaxShaderModelCS", &wined3d_settings.max_sm_cs)) TRACE("Limiting CS shader model to %u.\n", wined3d_settings.max_sm_cs); - if (!get_config_key(hkey, appkey, "DirectDrawRenderer", buffer, size) + if ((!get_config_key(hkey, appkey, "renderer", buffer, size) + || !get_config_key(hkey, appkey, "DirectDrawRenderer", buffer, size)) && !strcmp(buffer, "gdi")) { TRACE("Disabling 3D support.\n"); -- 2.11.0

1 0

[PATCH 1/5] d3d8/tests: Properly check whether creating a device succeeded in test_flip().
by Henri Verbeet 21 Sep '18

21 Sep '18

Perhaps CreateDevice() should clear the pointer on failure, but that's not documented behaviour, and Wine currently doesn't. Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/d3d8/tests/visual.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/dlls/d3d8/tests/visual.c b/dlls/d3d8/tests/visual.c index 24481bd0533..e8e6bf870e2 100644 --- a/dlls/d3d8/tests/visual.c +++ b/dlls/d3d8/tests/visual.c @@ -8154,9 +8154,8 @@ static void test_flip(void) present_parameters.Windowed = TRUE; present_parameters.BackBufferCount = 3; present_parameters.Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER; - hr = IDirect3D8_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, - window, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device); - if (!device) + if (FAILED(hr = IDirect3D8_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, + window, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device))) { skip("Failed to create a D3D device, skipping tests.\n"); IDirect3D8_Release(d3d); -- 2.11.0

1 0

[PATCH] dbghelp/dwarf: Use debugstr_a() to trace external strings.
by Zebediah Figura 21 Sep '18

21 Sep '18

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/dbghelp/dwarf.c | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/dlls/dbghelp/dwarf.c b/dlls/dbghelp/dwarf.c index 31c008a..26e2f42 100644 --- a/dlls/dbghelp/dwarf.c +++ b/dlls/dbghelp/dwarf.c @@ -568,7 +568,7 @@ static void dwarf2_fill_attr(const dwarf2_parse_context_t* ctx, case DW_FORM_string: attr->u.string = (const char *)data; - TRACE("string<%s>\n", attr->u.string); + TRACE("string<%s>\n", debugstr_a(attr->u.string)); break; case DW_FORM_strp: @@ -576,7 +576,7 @@ static void dwarf2_fill_attr(const dwarf2_parse_context_t* ctx, unsigned long offset = dwarf2_get_u4(data); attr->u.string = (const char*)ctx->sections[section_string].address + offset; } - TRACE("strp<%s>\n", attr->u.string); + TRACE("strp<%s>\n", debugstr_a(attr->u.string)); break; case DW_FORM_block: @@ -1613,7 +1613,7 @@ static void dwarf2_parse_variable(dwarf2_subprogram_t* subpgm, struct attribute ext; TRACE("found parameter %s (kind=%d, offset=%ld, reg=%d) at %s\n", - name.u.string, loc.kind, loc.offset, loc.reg, + debugstr_a(name.u.string), loc.kind, loc.offset, loc.reg, dwarf2_debug_ctx(subpgm->ctx)); switch (loc.kind) @@ -1648,8 +1648,8 @@ static void dwarf2_parse_variable(dwarf2_subprogram_t* subpgm, else if (dwarf2_find_attribute(subpgm->ctx, di, DW_AT_const_value, &value)) { VARIANT v; - if (subpgm->func) WARN("Unsupported constant %s in function\n", name.u.string); - if (is_pmt) FIXME("Unsupported constant (parameter) %s in function\n", name.u.string); + if (subpgm->func) WARN("Unsupported constant %s in function\n", debugstr_a(name.u.string)); + if (is_pmt) FIXME("Unsupported constant (parameter) %s in function\n", debugstr_a(name.u.string)); switch (value.form) { case DW_FORM_data1: @@ -1699,7 +1699,7 @@ static void dwarf2_parse_variable(dwarf2_subprogram_t* subpgm, default: FIXME("Unsupported form for const value %s (%lx)\n", - name.u.string, value.form); + debugstr_a(name.u.string), value.form); v.n1.n2.vt = VT_EMPTY; } di->symt = &symt_new_constant(subpgm->ctx->module, subpgm->ctx->compiland, @@ -1718,7 +1718,7 @@ static void dwarf2_parse_variable(dwarf2_subprogram_t* subpgm, } else { - WARN("dropping global variable %s which has been optimized away\n", name.u.string); + WARN("dropping global variable %s which has been optimized away\n", debugstr_a(name.u.string)); } } if (is_pmt && subpgm->func && subpgm->func->type) @@ -1933,7 +1933,7 @@ static struct symt* dwarf2_parse_subprogram(dwarf2_parse_context_t* ctx, } if (!dwarf2_read_range(ctx, di, &low_pc, &high_pc)) { - WARN("cannot get range for %s\n", name.u.string); + WARN("cannot get range for %s\n", debugstr_a(name.u.string)); return NULL; } /* As functions (defined as inline assembly) get debug info with dwarf @@ -2173,7 +2173,7 @@ static void dwarf2_set_line_number(struct module* module, unsigned long address, if (!file || !(psrc = vector_at(v, file - 1))) return; TRACE("%s %lx %s %u\n", - debugstr_w(module->module.ModuleName), address, source_get(module, *psrc), line); + debugstr_w(module->module.ModuleName), address, debugstr_a(source_get(module, *psrc)), line); if (!(symt = symt_find_nearest(module, address)) || symt->symt.tag != SymTagFunction) return; func = (struct symt_function*)symt; @@ -2234,7 +2234,7 @@ static BOOL dwarf2_parse_line_numbers(const dwarf2_section_t* sections, { const char* rel = (const char*)traverse.data; unsigned rellen = strlen(rel); - TRACE("Got include %s\n", rel); + TRACE("Got include %s\n", debugstr_a(rel)); traverse.data += rellen + 1; p = vector_add(&dirs, &ctx->pool); @@ -2268,7 +2268,7 @@ static BOOL dwarf2_parse_line_numbers(const dwarf2_section_t* sections, mod_time = dwarf2_leb128_as_unsigned(&traverse); length = dwarf2_leb128_as_unsigned(&traverse); dir = *(const char**)vector_at(&dirs, dir_index); - TRACE("Got file %s/%s (%u,%lu)\n", dir, name, mod_time, length); + TRACE("Got file %s/%s (%u,%lu)\n", debugstr_a(dir), debugstr_a(name), mod_time, length); psrc = vector_add(&files, &ctx->pool); *psrc = source_new(ctx->module, dir, name); } @@ -2339,7 +2339,7 @@ static BOOL dwarf2_parse_line_numbers(const dwarf2_section_t* sections, address = ctx->load_offset + dwarf2_parse_addr(&traverse); break; case DW_LNE_define_file: - FIXME("not handled define file %s\n", traverse.data); + FIXME("not handled define file %s\n", debugstr_a((char *)traverse.data)); traverse.data += strlen((const char *)traverse.data) + 1; dwarf2_leb128_as_unsigned(&traverse); dwarf2_leb128_as_unsigned(&traverse); @@ -2522,7 +2522,7 @@ static enum location_error loc_compute_frame(struct process* pcs, *frame = *pframe; break; case loc_dwarf2_location_list: - WARN("Searching loclist for %s\n", func->hash_elt.name); + WARN("Searching loclist for %s\n", debugstr_a(func->hash_elt.name)); if (!dwarf2_lookup_loclist(modfmt, modfmt->u.dwarf2_info->debug_loc.address + pframe->offset, ip, &lctx)) @@ -2668,7 +2668,7 @@ static BOOL parse_cie_details(dwarf2_traverse_context_t* ctx, struct frame_info* info->state.cfa_rule = RULE_CFA_OFFSET; end = NULL; - TRACE("\tparsing augmentation %s\n", augmentation); + TRACE("\tparsing augmentation %s\n", debugstr_a(augmentation)); if (*augmentation) do { switch (*augmentation) @@ -3325,7 +3325,7 @@ static void dwarf2_location_compute(struct process* pcs, if (!func->container || func->container->tag != SymTagCompiland) { - WARN("We'd expect function %s's container to exist and be a compiland\n", func->hash_elt.name); + WARN("We'd expect function %s's container to exist and be a compiland\n", debugstr_a(func->hash_elt.name)); err = loc_err_internal; } else @@ -3400,7 +3400,7 @@ static inline BOOL dwarf2_init_zsection(dwarf2_section_t* section, if (sz <= 12 || memcmp(sect, "ZLIB", 4)) { - ERR("invalid compressed section %s\n", zsectname); + ERR("invalid compressed section %s\n", debugstr_a(zsectname)); goto out; } @@ -3425,7 +3425,7 @@ static inline BOOL dwarf2_init_zsection(dwarf2_section_t* section, res = inflateInit(&z); if (res != Z_OK) { - FIXME("inflateInit failed with %i / %s\n", res, z.msg); + FIXME("inflateInit failed with %i / %s\n", res, debugstr_a(z.msg)); goto out_free; } @@ -3437,7 +3437,7 @@ static inline BOOL dwarf2_init_zsection(dwarf2_section_t* section, if (res != Z_STREAM_END) { - FIXME("Decompression failed with %i / %s\n", res, z.msg); + FIXME("Decompression failed with %i / %s\n", res, debugstr_a(z.msg)); goto out_end; } -- 2.7.4

1 0

[PATCH 1/4] quartz/filtergraph: Try other output pins if one shouldn't be rendered.
by Zebediah Figura 21 Sep '18

21 Sep '18

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/quartz/filtergraph.c | 3 +-- dlls/quartz/tests/filtergraph.c | 2 -- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/dlls/quartz/filtergraph.c b/dlls/quartz/filtergraph.c index 03d4091..8516dbf 100644 --- a/dlls/quartz/filtergraph.c +++ b/dlls/quartz/filtergraph.c @@ -1093,8 +1093,7 @@ static HRESULT connect_output_pin(IFilterGraphImpl *graph, IBaseFilter *filter, { TRACE("Skipping non-rendered pin %s.\n", debugstr_w(info.achName)); IPin_Release(pin); - IEnumPins_Release(enumpins); - return E_FAIL; + continue; } if (SUCCEEDED(IFilterGraph2_Connect(&graph->IFilterGraph2_iface, pin, sink))) diff --git a/dlls/quartz/tests/filtergraph.c b/dlls/quartz/tests/filtergraph.c index 9ef229f..30bf0cc 100644 --- a/dlls/quartz/tests/filtergraph.c +++ b/dlls/quartz/tests/filtergraph.c @@ -1783,11 +1783,9 @@ todo_wine parser1.pin_count = 3; hr = IFilterGraph2_Connect(graph, &source_pin.IPin_iface, &sink_pin.IPin_iface); -todo_wine { ok(hr == S_OK, "Got hr %#x.\n", hr); ok(source_pin.peer == &parser1_pins[0].IPin_iface, "Got peer %p.\n", source_pin.peer); ok(sink_pin.peer == &parser1_pins[2].IPin_iface, "Got peer %p.\n", sink_pin.peer); -} IFilterGraph2_Disconnect(graph, source_pin.peer); IFilterGraph2_Disconnect(graph, &source_pin.IPin_iface); IFilterGraph2_Disconnect(graph, sink_pin.peer); -- 2.7.4

2 4

[PATCH] msvcp90: Remove unnecessary check for __arm__.
by Huw Davies 21 Sep '18

21 Sep '18

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/msvcp90/misc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/msvcp90/misc.c b/dlls/msvcp90/misc.c index 0d1a74e250..ef0212958f 100644 --- a/dlls/msvcp90/misc.c +++ b/dlls/msvcp90/misc.c @@ -618,7 +618,7 @@ unsigned int __cdecl _Random_device(void) #endif #if _MSVCP_VER >= 110 -#if defined(__i386__) && !defined(__arm__) +#if defined(__i386__) extern void *call_thiscall_func; __ASM_GLOBAL_FUNC(call_thiscall_func, -- 2.18.0

3 2

[PATCH] dwmapi: return S_OK in DwmExtendFrameIntoClientArea
by Louis Lenders 21 Sep '18

21 Sep '18

Fix for bug 4583 To: wine-devel <wine-devel(a)winehq.org> (Note:also tested Steam that calls this function and didn`t see any negative side-effect of returning S_OK) Signed-off-by: Louis Lenders <xerox.xerox2000x(a)gmail.com> --- dlls/dwmapi/dwmapi_main.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/dwmapi/dwmapi_main.c b/dlls/dwmapi/dwmapi_main.c index 0e6ba3bed1..76e225f791 100644 --- a/dlls/dwmapi/dwmapi_main.c +++ b/dlls/dwmapi/dwmapi_main.c @@ -82,7 +82,7 @@ HRESULT WINAPI DwmExtendFrameIntoClientArea(HWND hwnd, const MARGINS* margins) { FIXME("(%p, %p) stub\n", hwnd, margins); - return E_NOTIMPL; + return S_OK; } /********************************************************************** -- 2.17.1

1 0

[PATCH v2 1/8] shell32/autocomplete: Fix going up through the suggestion listbox
by Gabriel Ivăncescu 21 Sep '18

21 Sep '18

When going up past the topmost item in the listbox, go through txtbackup first before wrapping around, just like when going down. This matches Windows behavior. Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- This series supersedes patches from 150637 to 150639. dlls/shell32/autocomplete.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/shell32/autocomplete.c b/dlls/shell32/autocomplete.c index e3fe1fd..0471146 100644 --- a/dlls/shell32/autocomplete.c +++ b/dlls/shell32/autocomplete.c @@ -296,7 +296,7 @@ static LRESULT ACEditSubclassProc_KeyDown(IAutoCompleteImpl *ac, HWND hwnd, UINT /* Change the selection */ sel = SendMessageW(ac->hwndListBox, LB_GETCURSEL, 0, 0); if (wParam == VK_UP) - sel = ((sel - 1) < 0) ? count - 1 : sel - 1; + sel = ((sel - 1) < -1) ? count - 1 : sel - 1; else sel = ((sel + 1) >= count) ? -1 : sel + 1; SendMessageW(ac->hwndListBox, LB_SETCURSEL, sel, 0); -- 1.9.1

4 34

[PATCH v4 3/3] comctl32/pager: Support comboboxex notification conversion.
by Zhiyi Zhang 21 Sep '18

21 Sep '18

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/comctl32/pager.c | 61 +++++++++++++++++++++++++++---- dlls/comctl32/tests/pager.c | 72 +++++++++++++++++++++++++++++++++++-- 2 files changed, 125 insertions(+), 8 deletions(-) diff --git a/dlls/comctl32/pager.c b/dlls/comctl32/pager.c index a6ef2eeadd..7fc0544ee4 100644 --- a/dlls/comctl32/pager.c +++ b/dlls/comctl32/pager.c @@ -101,7 +101,11 @@ enum conversion_flags /* Convert ANSI text from parent back to Unicode for children */ CONVERT_RECEIVE = 0x02, /* Send empty text to parent if text is NULL. Original text pointer still remains NULL */ - SEND_EMPTY_IF_NULL = 0x04 + SEND_EMPTY_IF_NULL = 0x04, + /* Set text to null after parent received the notification if the required mask is not set before sending notification */ + SET_NULL_IF_NO_MASK = 0x08, + /* Zero out the text buffer before sending it to parent */ + ZERO_SEND = 0x10 }; static void @@ -1038,6 +1042,10 @@ static UINT PAGER_GetAnsiNtfCode(UINT code) { switch (code) { + /* ComboxBoxEx */ + case CBEN_DRAGBEGINW: return CBEN_DRAGBEGINA; + case CBEN_ENDEDITW: return CBEN_ENDEDITA; + case CBEN_GETDISPINFOW: return CBEN_GETDISPINFOA; /* Toolbar */ case TBN_GETBUTTONINFOW: return TBN_GETBUTTONINFOA; case TBN_GETINFOTIPW: return TBN_GETINFOTIPA; @@ -1060,7 +1068,8 @@ static BOOL PAGER_AdjustBuffer(PAGER_INFO *infoPtr, INT size) return TRUE; } -static LRESULT PAGER_SendConvertedNotify(PAGER_INFO *infoPtr, NMHDR *hdr, WCHAR **text, INT *textMax, DWORD flags) +static LRESULT PAGER_SendConvertedNotify(PAGER_INFO *infoPtr, NMHDR *hdr, UINT *mask, UINT requiredMask, WCHAR **text, + INT *textMax, DWORD flags) { CHAR *sendBuffer = NULL; CHAR *receiveBuffer; @@ -1074,14 +1083,21 @@ static LRESULT PAGER_SendConvertedNotify(PAGER_INFO *infoPtr, NMHDR *hdr, WCHAR hdr->code = PAGER_GetAnsiNtfCode(hdr->code); + if (mask && !(*mask & requiredMask)) + { + ret = SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, hdr->idFrom, (LPARAM)hdr); + if (flags & SET_NULL_IF_NO_MASK) oldText = NULL; + goto done; + } + if (oldTextMax < 0) goto done; - if ((*text && (flags & CONVERT_SEND)) || (!*text && (flags & SEND_EMPTY_IF_NULL))) + if ((*text && flags & (CONVERT_SEND | ZERO_SEND)) || (!*text && flags & SEND_EMPTY_IF_NULL)) { bufferSize = textMax ? *textMax : lstrlenW(*text) + 1; sendBuffer = heap_alloc_zero(bufferSize); if (!sendBuffer) goto done; - WideCharToMultiByte(CP_ACP, 0, *text, -1, sendBuffer, bufferSize, NULL, FALSE); + if (!(flags & ZERO_SEND)) WideCharToMultiByte(CP_ACP, 0, *text, -1, sendBuffer, bufferSize, NULL, FALSE); *text = (WCHAR *)sendBuffer; } @@ -1117,17 +1133,50 @@ static LRESULT PAGER_Notify(PAGER_INFO *infoPtr, NMHDR *hdr) switch (hdr->code) { + /* ComboBoxEx */ + case CBEN_GETDISPINFOW: + { + NMCOMBOBOXEXW *nmcbe = (NMCOMBOBOXEXW *)hdr; + return PAGER_SendConvertedNotify(infoPtr, hdr, &nmcbe->ceItem.mask, CBEIF_TEXT, &nmcbe->ceItem.pszText, + &nmcbe->ceItem.cchTextMax, ZERO_SEND | SET_NULL_IF_NO_MASK | CONVERT_RECEIVE); + } + case CBEN_DRAGBEGINW: + { + NMCBEDRAGBEGINW *nmdbW = (NMCBEDRAGBEGINW *)hdr; + NMCBEDRAGBEGINA nmdbA = {0}; + nmdbA.hdr.code = PAGER_GetAnsiNtfCode(nmdbW->hdr.code); + nmdbA.hdr.hwndFrom = nmdbW->hdr.hwndFrom; + nmdbA.hdr.idFrom = nmdbW->hdr.idFrom; + nmdbA.iItemid = nmdbW->iItemid; + WideCharToMultiByte(CP_ACP, 0, nmdbW->szText, ARRAY_SIZE(nmdbW->szText), nmdbA.szText, ARRAY_SIZE(nmdbA.szText), + NULL, FALSE); + return SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, hdr->idFrom, (LPARAM)&nmdbA); + } + case CBEN_ENDEDITW: + { + NMCBEENDEDITW *nmedW = (NMCBEENDEDITW *)hdr; + NMCBEENDEDITA nmedA = {0}; + nmedA.hdr.code = PAGER_GetAnsiNtfCode(nmedW->hdr.code); + nmedA.hdr.hwndFrom = nmedW->hdr.hwndFrom; + nmedA.hdr.idFrom = nmedW->hdr.idFrom; + nmedA.fChanged = nmedW->fChanged; + nmedA.iNewSelection = nmedW->iNewSelection; + nmedA.iWhy = nmedW->iWhy; + WideCharToMultiByte(CP_ACP, 0, nmedW->szText, ARRAY_SIZE(nmedW->szText), nmedA.szText, ARRAY_SIZE(nmedA.szText), + NULL, FALSE); + return SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, hdr->idFrom, (LPARAM)&nmedA); + } /* Toolbar */ case TBN_GETBUTTONINFOW: { NMTOOLBARW *nmtb = (NMTOOLBARW *)hdr; - return PAGER_SendConvertedNotify(infoPtr, hdr, &nmtb->pszText, &nmtb->cchText, + return PAGER_SendConvertedNotify(infoPtr, hdr, NULL, 0, &nmtb->pszText, &nmtb->cchText, SEND_EMPTY_IF_NULL | CONVERT_SEND | CONVERT_RECEIVE); } case TBN_GETINFOTIPW: { NMTBGETINFOTIPW *nmtbgit = (NMTBGETINFOTIPW *)hdr; - return PAGER_SendConvertedNotify(infoPtr, hdr, &nmtbgit->pszText, &nmtbgit->cchTextMax, CONVERT_RECEIVE); + return PAGER_SendConvertedNotify(infoPtr, hdr, NULL, 0, &nmtbgit->pszText, &nmtbgit->cchTextMax, CONVERT_RECEIVE); } /* Tooltip */ case TTN_GETDISPINFOW: diff --git a/dlls/comctl32/tests/pager.c b/dlls/comctl32/tests/pager.c index cd7b637b91..b689549aa5 100644 --- a/dlls/comctl32/tests/pager.c +++ b/dlls/comctl32/tests/pager.c @@ -65,7 +65,9 @@ enum test_conversion_flags CONVERT_RECEIVE = 0x04, DONT_CONVERT_RECEIVE = 0x08, SEND_EMPTY_IF_NULL = 0x10, - DONT_SEND_EMPTY_IF_NULL = 0x20 + DONT_SEND_EMPTY_IF_NULL = 0x20, + SET_NULL_IF_NO_MASK = 0x40, + ZERO_SEND = 0x80 }; static struct notify_test_info @@ -578,7 +580,10 @@ static void notify_generic_text_handler(CHAR **text, INT *text_max) { send_data = (notify_test_info.test_id == CONVERT_SEND ? test_convert_send_data : test_dont_convert_send_data) + notify_test_info.sub_test_id; - if (notify_test_info.flags & CONVERT_SEND) + if (notify_test_info.flags & ZERO_SEND) + ok(!lstrcmpA(*text, empty_a), "Code 0x%08x test 0x%08x sub test %d expect empty text, got %s\n", + notify_test_info.unicode, notify_test_info.test_id, notify_test_info.sub_test_id, *text); + else if (notify_test_info.flags & CONVERT_SEND) ok(!lstrcmpA(send_data->expect_text, *text), "Code 0x%08x test 0x%08x sub test %d expect %s, got %s\n", notify_test_info.unicode, notify_test_info.test_id, notify_test_info.sub_test_id, (CHAR *)send_data->expect_text, *text); @@ -659,6 +664,32 @@ static LRESULT WINAPI test_notify_proc(HWND hwnd, UINT message, WPARAM wParam, L } switch (hdr->code) { + /* ComboBoxEx */ + case CBEN_INSERTITEM: + case CBEN_DELETEITEM: + { + NMCOMBOBOXEXW *nmcbe = (NMCOMBOBOXEXW *)hdr; + notify_generic_text_handler((CHAR **)&nmcbe->ceItem.pszText, NULL); + break; + } + case CBEN_DRAGBEGINA: + { + NMCBEDRAGBEGINA *nmcbedb = (NMCBEDRAGBEGINA *)hdr; + ok(!lstrcmpA(nmcbedb->szText, test_a), "Expect %s, got %s\n", nmcbedb->szText, test_a); + break; + } + case CBEN_ENDEDITA: + { + NMCBEENDEDITA *nmcbeed = (NMCBEENDEDITA *)hdr; + ok(!lstrcmpA(nmcbeed->szText, test_a), "Expect %s, got %s\n", nmcbeed->szText, test_a); + break; + } + case CBEN_GETDISPINFOA: + { + NMCOMBOBOXEXA *nmcbe = (NMCOMBOBOXEXA *)hdr; + notify_generic_text_handler(&nmcbe->ceItem.pszText, &nmcbe->ceItem.cchTextMax); + break; + } /* Toolbar */ case TBN_SAVE: { @@ -836,6 +867,33 @@ static void test_notify_generic_text_helper(HWND pager, const struct generic_tex else notify_test_info.test_id = DONT_SEND_EMPTY_IF_NULL; send_notify(pager, para->code_unicode, para->code_ansi, (LPARAM)para->ptr, TRUE); + + notify_test_info.test_id = SET_NULL_IF_NO_MASK; + memset(para->ptr, 0, para->size); + memset(buffer, 0, sizeof(buffer)); + *para->text = buffer; + if (para->text_max) *para->text_max = ARRAY_SIZE(buffer); + send_notify(pager, para->code_unicode, para->code_ansi, (LPARAM)para->ptr, TRUE); + if(para->flags & SET_NULL_IF_NO_MASK) + ok(!*para->text, "Expect null text\n"); +} + +static void test_wm_notify_comboboxex(HWND pager) +{ + static NMCBEDRAGBEGINW nmcbedb; + static NMCBEENDEDITW nmcbeed; + + /* CBEN_DRAGBEGIN */ + memset(&nmcbedb, 0, sizeof(nmcbedb)); + memcpy(nmcbedb.szText, test_w, sizeof(test_w)); + send_notify(pager, CBEN_DRAGBEGINW, CBEN_DRAGBEGINA, (LPARAM)&nmcbedb, FALSE); + ok(!lstrcmpW(nmcbedb.szText, test_w), "Expect %s, got %s\n", wine_dbgstr_w(test_w), wine_dbgstr_w(nmcbedb.szText)); + + /* CBEN_ENDEDIT */ + memset(&nmcbeed, 0, sizeof(nmcbeed)); + memcpy(nmcbeed.szText, test_w, sizeof(test_w)); + send_notify(pager, CBEN_ENDEDITW, CBEN_ENDEDITA, (LPARAM)&nmcbeed, FALSE); + ok(!lstrcmpW(nmcbeed.szText, test_w), "Expect %s, got %s\n", wine_dbgstr_w(test_w), wine_dbgstr_w(nmcbeed.szText)); } static void test_wm_notify_tooltip(HWND pager) @@ -880,6 +938,8 @@ static void test_wm_notify(void) { static const CHAR *class = "Pager notify class"; HWND parent, pager; + /* Combo Box Ex */ + static NMCOMBOBOXEXW nmcbe; /* Tool Bar */ static NMTBRESTORE nmtbr; static NMTBSAVE nmtbs; @@ -888,6 +948,13 @@ static void test_wm_notify(void) static NMTBGETINFOTIPW nmtbgit; static const struct generic_text_helper_para paras[] = { + /* Combo Box Ex */ + {&nmcbe, sizeof(nmcbe), &nmcbe.ceItem.mask, CBEIF_TEXT, &nmcbe.ceItem.pszText, &nmcbe.ceItem.cchTextMax, + CBEN_INSERTITEM, CBEN_INSERTITEM, DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE}, + {&nmcbe, sizeof(nmcbe), &nmcbe.ceItem.mask, CBEIF_TEXT, &nmcbe.ceItem.pszText, &nmcbe.ceItem.cchTextMax, + CBEN_DELETEITEM, CBEN_DELETEITEM, DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE}, + {&nmcbe, sizeof(nmcbe), &nmcbe.ceItem.mask, CBEIF_TEXT, &nmcbe.ceItem.pszText, &nmcbe.ceItem.cchTextMax, + CBEN_GETDISPINFOW, CBEN_GETDISPINFOA, ZERO_SEND | SET_NULL_IF_NO_MASK | DONT_CONVERT_SEND | CONVERT_RECEIVE}, /* Tool Bar */ {&nmtbs, sizeof(nmtbs), NULL, 0, (WCHAR **)&nmtbs.tbButton.iString, NULL, TBN_SAVE, TBN_SAVE, DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE}, @@ -916,6 +983,7 @@ static void test_wm_notify(void) test_notify_generic_text_helper(pager, paras + i); /* Tests for those that can't be covered by generic text test helper */ + test_wm_notify_comboboxex(pager); test_wm_notify_tooltip(pager); DestroyWindow(parent); -- 2.18.0

2 1

[PATCH v4 2/3] comctl32/pager: Support tooltip notification conversion.
by Zhiyi Zhang 21 Sep '18

21 Sep '18

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/comctl32/pager.c | 72 ++++++++++++++++++++++++ dlls/comctl32/tests/pager.c | 106 ++++++++++++++++++++++++++++++++++++ 2 files changed, 178 insertions(+) diff --git a/dlls/comctl32/pager.c b/dlls/comctl32/pager.c index ac63f1c07d..a6ef2eeadd 100644 --- a/dlls/comctl32/pager.c +++ b/dlls/comctl32/pager.c @@ -84,6 +84,8 @@ typedef struct INT TLbtnState; /* state of top or left btn */ INT BRbtnState; /* state of bottom or right btn */ INT direction; /* direction of the scroll, (e.g. PGF_SCROLLUP) */ + WCHAR *pwszBuffer;/* text buffer for converted notifications */ + INT nBufferSize;/* size of the above buffer */ } PAGER_INFO; #define TIMERID1 1 @@ -605,6 +607,7 @@ static LRESULT PAGER_Destroy (PAGER_INFO *infoPtr) { SetWindowLongPtrW (infoPtr->hwndSelf, 0, 0); + heap_free (infoPtr->pwszBuffer); heap_free (infoPtr); return 0; } @@ -1038,10 +1041,25 @@ static UINT PAGER_GetAnsiNtfCode(UINT code) /* Toolbar */ case TBN_GETBUTTONINFOW: return TBN_GETBUTTONINFOA; case TBN_GETINFOTIPW: return TBN_GETINFOTIPA; + /* Tooltip */ + case TTN_GETDISPINFOW: return TTN_GETDISPINFOA; } return code; } +static BOOL PAGER_AdjustBuffer(PAGER_INFO *infoPtr, INT size) +{ + if (!infoPtr->pwszBuffer) + infoPtr->pwszBuffer = heap_alloc(size); + else if (infoPtr->nBufferSize < size) + infoPtr->pwszBuffer = heap_realloc(infoPtr->pwszBuffer, size); + + if (!infoPtr->pwszBuffer) return FALSE; + if (infoPtr->nBufferSize < size) infoPtr->nBufferSize = size; + + return TRUE; +} + static LRESULT PAGER_SendConvertedNotify(PAGER_INFO *infoPtr, NMHDR *hdr, WCHAR **text, INT *textMax, DWORD flags) { CHAR *sendBuffer = NULL; @@ -1093,6 +1111,8 @@ done: static LRESULT PAGER_Notify(PAGER_INFO *infoPtr, NMHDR *hdr) { + LRESULT ret; + if (infoPtr->bUnicode) return SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, hdr->idFrom, (LPARAM)hdr); switch (hdr->code) @@ -1109,6 +1129,58 @@ static LRESULT PAGER_Notify(PAGER_INFO *infoPtr, NMHDR *hdr) NMTBGETINFOTIPW *nmtbgit = (NMTBGETINFOTIPW *)hdr; return PAGER_SendConvertedNotify(infoPtr, hdr, &nmtbgit->pszText, &nmtbgit->cchTextMax, CONVERT_RECEIVE); } + /* Tooltip */ + case TTN_GETDISPINFOW: + { + NMTTDISPINFOW *nmttdiW = (NMTTDISPINFOW *)hdr; + NMTTDISPINFOA nmttdiA = {0}; + INT size; + + nmttdiA.hdr.code = PAGER_GetAnsiNtfCode(nmttdiW->hdr.code); + nmttdiA.hdr.hwndFrom = nmttdiW->hdr.hwndFrom; + nmttdiA.hdr.idFrom = nmttdiW->hdr.idFrom; + nmttdiA.hinst = nmttdiW->hinst; + nmttdiA.uFlags = nmttdiW->uFlags; + nmttdiA.lParam = nmttdiW->lParam; + nmttdiA.lpszText = nmttdiA.szText; + WideCharToMultiByte(CP_ACP, 0, nmttdiW->szText, ARRAY_SIZE(nmttdiW->szText), nmttdiA.szText, + ARRAY_SIZE(nmttdiA.szText), NULL, FALSE); + + ret = SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, hdr->idFrom, (LPARAM)&nmttdiA); + + nmttdiW->hinst = nmttdiA.hinst; + nmttdiW->uFlags = nmttdiA.uFlags; + nmttdiW->lParam = nmttdiA.lParam; + + MultiByteToWideChar(CP_ACP, 0, nmttdiA.szText, ARRAY_SIZE(nmttdiA.szText), nmttdiW->szText, + ARRAY_SIZE(nmttdiW->szText)); + if (!nmttdiA.lpszText) + nmttdiW->lpszText = nmttdiW->szText; + else if (!IS_INTRESOURCE(nmttdiA.lpszText)) + { + size = MultiByteToWideChar(CP_ACP, 0, nmttdiA.lpszText, -1, 0, 0); + if (size > ARRAY_SIZE(nmttdiW->szText)) + { + if (!PAGER_AdjustBuffer(infoPtr, size * sizeof(WCHAR))) return ret; + MultiByteToWideChar(CP_ACP, 0, nmttdiA.lpszText, -1, infoPtr->pwszBuffer, size); + nmttdiW->lpszText = infoPtr->pwszBuffer; + /* Override content in szText */ + memcpy(nmttdiW->szText, nmttdiW->lpszText, min(sizeof(nmttdiW->szText), size * sizeof(WCHAR))); + } + else + { + MultiByteToWideChar(CP_ACP, 0, nmttdiA.lpszText, -1, nmttdiW->szText, ARRAY_SIZE(nmttdiW->szText)); + nmttdiW->lpszText = nmttdiW->szText; + } + } + else + { + nmttdiW->szText[0] = 0; + nmttdiW->lpszText = (WCHAR *)nmttdiA.lpszText; + } + + return ret; + } } /* Other notifications, no need to convert */ return SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, hdr->idFrom, (LPARAM)hdr); diff --git a/dlls/comctl32/tests/pager.c b/dlls/comctl32/tests/pager.c index 6ff4e259ca..cd7b637b91 100644 --- a/dlls/comctl32/tests/pager.c +++ b/dlls/comctl32/tests/pager.c @@ -35,12 +35,26 @@ static CHAR test_a[] = {'t', 'e', 's', 't', 0}; static WCHAR empty_w[] = {0}; static CHAR empty_a[] = {0}; static CHAR large_a[] = "You should have received a copy of the GNU Lesser General Public License along with this ..."; +static WCHAR large_w[] = +{ + 'Y', 'o', 'u', ' ', 's', 'h', 'o', 'u', 'l', 'd', ' ', 'h', 'a', 'v', 'e', ' ', 'r', 'e', 'c', 'e', 'i', 'v', 'e', + 'd', ' ', 'a', ' ', 'c', 'o', 'p', 'y', ' ', 'o', 'f', ' ', 't', 'h', 'e', ' ', 'G', 'N', 'U', ' ', 'L', 'e', 's', + 's', 'e', 'r', ' ', 'G', 'e', 'n', 'e', 'r', 'a', 'l', ' ', 'P', 'u', 'b', 'l', 'i', 'c', ' ', 'L', 'i', 'c', 'e', + 'n', 's', 'e', ' ', 'a', 'l', 'o', 'n', 'g', ' ', 'w', 'i', 't', 'h', ' ', 't', 'h', 'i', 's', ' ', '.', '.', '.', 0 +}; static WCHAR large_truncated_65_w[65] = { 'Y', 'o', 'u', ' ', 's', 'h', 'o', 'u', 'l', 'd', ' ', 'h', 'a', 'v', 'e', ' ', 'r', 'e', 'c', 'e', 'i', 'v', 'e', 'd', ' ', 'a', ' ', 'c', 'o', 'p', 'y', ' ', 'o', 'f', ' ', 't', 'h', 'e', ' ', 'G', 'N', 'U', ' ', 'L', 'e', 's', 's', 'e', 'r', ' ', 'G', 'e', 'n', 'e', 'r', 'a', 'l', ' ', 'P', 'u', 'b', 'l', 'i', 'c', 0 }; +static WCHAR large_truncated_80_w[80] = +{ + 'Y', 'o', 'u', ' ', 's', 'h', 'o', 'u', 'l', 'd', ' ', 'h', 'a', 'v', 'e', ' ', 'r', 'e', 'c', 'e', + 'i', 'v', 'e', 'd', ' ', 'a', ' ', 'c', 'o', 'p', 'y', ' ', 'o', 'f', ' ', 't', 'h', 'e', ' ', 'G', + 'N', 'U', ' ', 'L', 'e', 's', 's', 'e', 'r', ' ', 'G', 'e', 'n', 'e', 'r', 'a', 'l', ' ', 'P', 'u', + 'b', 'l', 'i', 'c', ' ', 'L', 'i', 'c', 'e', 'n', 's', 'e', ' ', 'a', 'l', 'o', 'n', 'g', ' ', 'w' +}; static WCHAR buffer[64]; /* Text field conversion test behavior flags. */ @@ -132,6 +146,38 @@ static const struct notify_test_receive test_dont_convert_receive_data[] = {empty_w, sizeof(empty_w), ARRAY_SIZE(buffer), test_a, NULL, 0, -1, test_a, ARRAY_SIZE(buffer)}, }; +static const struct notify_test_tooltip +{ + /* Data for parent to write */ + CHAR *write_sztext; + INT write_sztext_size; + CHAR *write_lpsztext; + HMODULE write_hinst; + /* Data when message returned */ + WCHAR *return_sztext; + INT return_sztext_size; + WCHAR *return_lpsztext; + HMODULE return_hinst; + /* Data expected by parent */ + CHAR *expect_sztext; + /* Data send to parent */ + WCHAR *send_sztext; + INT send_sztext_size; + WCHAR *send_lpsztext; +} test_tooltip_data[] = +{ + {NULL, 0, NULL, NULL, empty_w, -1, empty_w}, + {test_a, sizeof(test_a), NULL, NULL, test_w, -1, test_w}, + {test_a, sizeof(test_a), test_a, NULL, test_w, -1, test_w}, + {test_a, sizeof(test_a), (CHAR *)1, (HMODULE)0xdeadbeef, empty_w, -1, (WCHAR *)1, (HMODULE)0xdeadbeef}, + {test_a, sizeof(test_a), test_a, (HMODULE)0xdeadbeef, test_w, -1, test_w, (HMODULE)0xdeadbeef}, + {NULL, 0, test_a, NULL, test_w, -1, test_w}, + {test_a, 2, test_a, NULL, test_w, -1, test_w}, + {NULL, 0, NULL, NULL, test_w, -1, test_w, NULL, test_a, test_w, sizeof(test_w)}, + {NULL, 0, NULL, NULL, empty_w, -1, empty_w, NULL, empty_a, NULL, 0, test_w}, + {NULL, 0, large_a, NULL, large_truncated_80_w, sizeof(large_truncated_80_w), large_w} +}; + #define CHILD1_ID 1 #define CHILD2_ID 2 @@ -575,6 +621,19 @@ static void notify_generic_text_handler(CHAR **text, INT *text_max) } } +static void notify_tooltip_handler(NMTTDISPINFOA *nm) +{ + const struct notify_test_tooltip *data = test_tooltip_data + notify_test_info.sub_test_id; + ok(nm->lpszText == nm->szText, "Sub test %d expect %p, got %p\n", notify_test_info.sub_test_id, nm->szText, + nm->lpszText); + if (data->expect_sztext) + ok(!lstrcmpA(data->expect_sztext, nm->szText), "Sub test %d expect %s, got %s\n", notify_test_info.sub_test_id, + data->expect_sztext, nm->szText); + if (data->write_sztext) memcpy(nm->szText, data->write_sztext, data->write_sztext_size); + if (data->write_lpsztext) nm->lpszText = data->write_lpsztext; + if (data->write_hinst) nm->hinst = data->write_hinst; +} + static LRESULT WINAPI test_notify_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { static const WCHAR test[] = {'t', 'e', 's', 't', 0}; @@ -631,6 +690,12 @@ static LRESULT WINAPI test_notify_proc(HWND hwnd, UINT message, WPARAM wParam, L notify_generic_text_handler(&nmtbgit->pszText, &nmtbgit->cchTextMax); break; } + /* Tooltip */ + case TTN_GETDISPINFOA: + { + notify_tooltip_handler((NMTTDISPINFOA *)hdr); + break; + } default: ok(0, "Unexpected message 0x%08x\n", hdr->code); } @@ -773,6 +838,44 @@ static void test_notify_generic_text_helper(HWND pager, const struct generic_tex send_notify(pager, para->code_unicode, para->code_ansi, (LPARAM)para->ptr, TRUE); } +static void test_wm_notify_tooltip(HWND pager) +{ + NMTTDISPINFOW nmttdi; + const struct notify_test_tooltip *data; + INT i; + + for (i = 0; i < ARRAY_SIZE(test_tooltip_data); i++) + { + data = test_tooltip_data + i; + notify_test_info.sub_test_id = i; + + memset(&nmttdi, 0, sizeof(nmttdi)); + if (data->send_sztext) memcpy(nmttdi.szText, data->send_sztext, data->send_sztext_size); + if (data->send_lpsztext) nmttdi.lpszText = data->send_lpsztext; + send_notify(pager, TTN_GETDISPINFOW, TTN_GETDISPINFOA, (LPARAM)&nmttdi, FALSE); + if (data->return_sztext) + { + if (data->return_sztext_size == -1) + ok(!lstrcmpW(nmttdi.szText, data->return_sztext), "Sub test %d expect %s, got %s\n", i, + wine_dbgstr_w(data->return_sztext), wine_dbgstr_w(nmttdi.szText)); + else + ok(!memcmp(nmttdi.szText, data->return_sztext, data->return_sztext_size), "Wrong szText content\n"); + } + if (data->return_lpsztext) + { + if (IS_INTRESOURCE(data->return_lpsztext)) + ok(nmttdi.lpszText == data->return_lpsztext, "Sub test %d expect %s, got %s\n", i, + wine_dbgstr_w(data->return_lpsztext), wine_dbgstr_w(nmttdi.lpszText)); + else + ok(!lstrcmpW(nmttdi.lpszText, data->return_lpsztext), "Test %d expect %s, got %s\n", i, + wine_dbgstr_w(data->return_lpsztext), wine_dbgstr_w(nmttdi.lpszText)); + } + if (data->return_hinst) + ok(nmttdi.hinst == data->return_hinst, "Sub test %d expect %p, got %p\n", i, data->return_hinst, + nmttdi.hinst); + } +} + static void test_wm_notify(void) { static const CHAR *class = "Pager notify class"; @@ -812,6 +915,9 @@ static void test_wm_notify(void) for (i = 0; i < ARRAY_SIZE(paras); i++) test_notify_generic_text_helper(pager, paras + i); + /* Tests for those that can't be covered by generic text test helper */ + test_wm_notify_tooltip(pager); + DestroyWindow(parent); UnregisterClassA(class, GetModuleHandleA(NULL)); } -- 2.18.0

2 1

[PATCH v4 1/3] comctl32/pager: Support toolbar notification conversion.
by Zhiyi Zhang 21 Sep '18

21 Sep '18

Fix BibleWorks 10 not displaying toolbar. Pager always wants Unicode notifications from its children. And the parent of pager may want ANSI notifications. In this case, pager need to convert Unicode notifications to ANSI ones before sending them to parent and convert ANSI notifications from parent to Unicode before returning the result to its children. Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- v4: Supersede 150964,150965,150966. Minor changes as suggested by Nikolay. dlls/comctl32/pager.c | 96 +++++++++ dlls/comctl32/tests/pager.c | 398 ++++++++++++++++++++++++++++++++++++ 2 files changed, 494 insertions(+) diff --git a/dlls/comctl32/pager.c b/dlls/comctl32/pager.c index de63cad717..ac63f1c07d 100644 --- a/dlls/comctl32/pager.c +++ b/dlls/comctl32/pager.c @@ -91,6 +91,17 @@ typedef struct #define INITIAL_DELAY 500 #define REPEAT_DELAY 50 +/* Text field conversion behavior flags for PAGER_SendConvertedNotify() */ +enum conversion_flags +{ + /* Convert Unicode text to ANSI for parent before sending. If not set, do nothing */ + CONVERT_SEND = 0x01, + /* Convert ANSI text from parent back to Unicode for children */ + CONVERT_RECEIVE = 0x02, + /* Send empty text to parent if text is NULL. Original text pointer still remains NULL */ + SEND_EMPTY_IF_NULL = 0x04 +}; + static void PAGER_GetButtonRects(const PAGER_INFO* infoPtr, RECT* prcTopLeft, RECT* prcBottomRight, BOOL bClientCoords) { @@ -1020,6 +1031,89 @@ static LRESULT PAGER_NotifyFormat(PAGER_INFO *infoPtr, INT command) } } +static UINT PAGER_GetAnsiNtfCode(UINT code) +{ + switch (code) + { + /* Toolbar */ + case TBN_GETBUTTONINFOW: return TBN_GETBUTTONINFOA; + case TBN_GETINFOTIPW: return TBN_GETINFOTIPA; + } + return code; +} + +static LRESULT PAGER_SendConvertedNotify(PAGER_INFO *infoPtr, NMHDR *hdr, WCHAR **text, INT *textMax, DWORD flags) +{ + CHAR *sendBuffer = NULL; + CHAR *receiveBuffer; + INT bufferSize; + WCHAR *oldText; + INT oldTextMax; + LRESULT ret = NO_ERROR; + + oldText = *text; + oldTextMax = textMax ? *textMax : 0; + + hdr->code = PAGER_GetAnsiNtfCode(hdr->code); + + if (oldTextMax < 0) goto done; + + if ((*text && (flags & CONVERT_SEND)) || (!*text && (flags & SEND_EMPTY_IF_NULL))) + { + bufferSize = textMax ? *textMax : lstrlenW(*text) + 1; + sendBuffer = heap_alloc_zero(bufferSize); + if (!sendBuffer) goto done; + WideCharToMultiByte(CP_ACP, 0, *text, -1, sendBuffer, bufferSize, NULL, FALSE); + *text = (WCHAR *)sendBuffer; + } + + ret = SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, hdr->idFrom, (LPARAM)hdr); + + if (*text && oldText && (flags & CONVERT_RECEIVE)) + { + /* MultiByteToWideChar requires that source and destination are not the same buffer */ + if (*text == oldText) + { + bufferSize = lstrlenA((CHAR *)*text) + 1; + receiveBuffer = heap_alloc(bufferSize); + if (!receiveBuffer) goto done; + memcpy(receiveBuffer, *text, bufferSize); + MultiByteToWideChar(CP_ACP, 0, receiveBuffer, bufferSize, oldText, oldTextMax); + heap_free(receiveBuffer); + } + else + MultiByteToWideChar(CP_ACP, 0, (CHAR *)*text, -1, oldText, oldTextMax); + } + +done: + heap_free(sendBuffer); + *text = oldText; + return ret; +} + +static LRESULT PAGER_Notify(PAGER_INFO *infoPtr, NMHDR *hdr) +{ + if (infoPtr->bUnicode) return SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, hdr->idFrom, (LPARAM)hdr); + + switch (hdr->code) + { + /* Toolbar */ + case TBN_GETBUTTONINFOW: + { + NMTOOLBARW *nmtb = (NMTOOLBARW *)hdr; + return PAGER_SendConvertedNotify(infoPtr, hdr, &nmtb->pszText, &nmtb->cchText, + SEND_EMPTY_IF_NULL | CONVERT_SEND | CONVERT_RECEIVE); + } + case TBN_GETINFOTIPW: + { + NMTBGETINFOTIPW *nmtbgit = (NMTBGETINFOTIPW *)hdr; + return PAGER_SendConvertedNotify(infoPtr, hdr, &nmtbgit->pszText, &nmtbgit->cchTextMax, CONVERT_RECEIVE); + } + } + /* Other notifications, no need to convert */ + return SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, hdr->idFrom, (LPARAM)hdr); +} + static LRESULT WINAPI PAGER_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { @@ -1115,6 +1209,8 @@ PAGER_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) return PAGER_NotifyFormat (infoPtr, lParam); case WM_NOTIFY: + return PAGER_Notify (infoPtr, (NMHDR *)lParam); + case WM_COMMAND: return SendMessageW (infoPtr->hwndNotify, uMsg, wParam, lParam); diff --git a/dlls/comctl32/tests/pager.c b/dlls/comctl32/tests/pager.c index a1f6683a57..6ff4e259ca 100644 --- a/dlls/comctl32/tests/pager.c +++ b/dlls/comctl32/tests/pager.c @@ -30,6 +30,107 @@ static HWND parent_wnd, child1_wnd, child2_wnd; static INT notify_format; static BOOL notify_query_received; +static WCHAR test_w[] = {'t', 'e', 's', 't', 0}; +static CHAR test_a[] = {'t', 'e', 's', 't', 0}; +static WCHAR empty_w[] = {0}; +static CHAR empty_a[] = {0}; +static CHAR large_a[] = "You should have received a copy of the GNU Lesser General Public License along with this ..."; +static WCHAR large_truncated_65_w[65] = +{ + 'Y', 'o', 'u', ' ', 's', 'h', 'o', 'u', 'l', 'd', ' ', 'h', 'a', 'v', 'e', ' ', 'r', 'e', 'c', 'e', 'i', 'v', + 'e', 'd', ' ', 'a', ' ', 'c', 'o', 'p', 'y', ' ', 'o', 'f', ' ', 't', 'h', 'e', ' ', 'G', 'N', 'U', ' ', 'L', + 'e', 's', 's', 'e', 'r', ' ', 'G', 'e', 'n', 'e', 'r', 'a', 'l', ' ', 'P', 'u', 'b', 'l', 'i', 'c', 0 +}; +static WCHAR buffer[64]; + +/* Text field conversion test behavior flags. */ +enum test_conversion_flags +{ + CONVERT_SEND = 0x01, + DONT_CONVERT_SEND = 0x02, + CONVERT_RECEIVE = 0x04, + DONT_CONVERT_RECEIVE = 0x08, + SEND_EMPTY_IF_NULL = 0x10, + DONT_SEND_EMPTY_IF_NULL = 0x20 +}; + +static struct notify_test_info +{ + UINT unicode; + UINT ansi; + UINT_PTR id_from; + HWND hwnd_from; + /* Whether parent received notification */ + BOOL received; + UINT test_id; + UINT sub_test_id; + /* Text field conversion test behavior flag */ + DWORD flags; +} notify_test_info; + +struct notify_test_send +{ + /* Data sent to pager */ + WCHAR *send_text; + INT send_text_size; + INT send_text_max; + /* Data expected by parent of pager */ + void *expect_text; +}; + +struct notify_test_receive +{ + /* Data sent to pager */ + WCHAR *send_text; + INT send_text_size; + INT send_text_max; + /* Data for parent to write */ + CHAR *write_pointer; + CHAR *write_text; + INT write_text_size; + INT write_text_max; + /* Data when message returned */ + void *return_text; + INT return_text_max; +}; + +struct generic_text_helper_para +{ + void *ptr; + size_t size; + UINT *mask; + UINT required_mask; + WCHAR **text; + INT *text_max; + UINT code_unicode; + UINT code_ansi; + DWORD flags; +}; + +static const struct notify_test_send test_convert_send_data[] = +{ + {test_w, sizeof(test_w), ARRAY_SIZE(buffer), test_a} +}; + +static const struct notify_test_send test_dont_convert_send_data[] = +{ + {test_w, sizeof(test_w), ARRAY_SIZE(buffer), test_w} +}; + +static const struct notify_test_receive test_convert_receive_data[] = +{ + {empty_w, sizeof(empty_w), ARRAY_SIZE(buffer), NULL, test_a, sizeof(test_a), -1, test_w, ARRAY_SIZE(buffer)}, + {empty_w, sizeof(empty_w), ARRAY_SIZE(buffer), test_a, NULL, 0, -1, test_w, ARRAY_SIZE(buffer)}, + {NULL, sizeof(empty_w), ARRAY_SIZE(buffer), test_a, NULL, 0, -1, NULL, ARRAY_SIZE(buffer)}, + {empty_w, sizeof(empty_w), ARRAY_SIZE(buffer), large_a, NULL, 0, -1, large_truncated_65_w, ARRAY_SIZE(buffer)}, + {empty_w, sizeof(empty_w), ARRAY_SIZE(buffer), empty_a, 0, 0, 1, empty_w, 1}, +}; + +static const struct notify_test_receive test_dont_convert_receive_data[] = +{ + {empty_w, sizeof(empty_w), ARRAY_SIZE(buffer), NULL, test_a, sizeof(test_a), -1, test_a, ARRAY_SIZE(buffer)}, + {empty_w, sizeof(empty_w), ARRAY_SIZE(buffer), test_a, NULL, 0, -1, test_a, ARRAY_SIZE(buffer)}, +}; #define CHILD1_ID 1 #define CHILD2_ID 2 @@ -419,6 +520,302 @@ static void test_wm_notifyformat(void) UnregisterClassW(class_w, GetModuleHandleW(NULL)); } +static void notify_generic_text_handler(CHAR **text, INT *text_max) +{ + const struct notify_test_send *send_data; + const struct notify_test_receive *receive_data; + + switch (notify_test_info.test_id) + { + case CONVERT_SEND: + case DONT_CONVERT_SEND: + { + send_data = (notify_test_info.test_id == CONVERT_SEND ? test_convert_send_data : test_dont_convert_send_data) + + notify_test_info.sub_test_id; + if (notify_test_info.flags & CONVERT_SEND) + ok(!lstrcmpA(send_data->expect_text, *text), "Code 0x%08x test 0x%08x sub test %d expect %s, got %s\n", + notify_test_info.unicode, notify_test_info.test_id, notify_test_info.sub_test_id, + (CHAR *)send_data->expect_text, *text); + else + ok(!lstrcmpW((WCHAR *)send_data->expect_text, (WCHAR *)*text), + "Code 0x%08x test 0x%08x sub test %d expect %s, got %s\n", notify_test_info.unicode, + notify_test_info.test_id, notify_test_info.sub_test_id, wine_dbgstr_w((WCHAR *)send_data->expect_text), + wine_dbgstr_w((WCHAR *)*text)); + if (text_max) + ok(*text_max == send_data->send_text_max, "Code 0x%08x test 0x%08x sub test %d expect %d, got %d\n", + notify_test_info.unicode, notify_test_info.test_id, notify_test_info.sub_test_id, + send_data->send_text_max, *text_max); + break; + } + case CONVERT_RECEIVE: + case DONT_CONVERT_RECEIVE: + { + receive_data = (notify_test_info.test_id == CONVERT_RECEIVE ? test_convert_receive_data : test_dont_convert_receive_data) + + notify_test_info.sub_test_id; + if (text_max) + ok(*text_max == receive_data->send_text_max, "Code 0x%08x test 0x%08x sub test %d expect %d, got %d\n", + notify_test_info.unicode, notify_test_info.test_id, notify_test_info.sub_test_id, + receive_data->send_text_max, *text_max); + + if (receive_data->write_text) + memcpy(*text, receive_data->write_text, receive_data->write_text_size); + else + *text = receive_data->write_pointer; + if (text_max && receive_data->write_text_max != -1) *text_max = receive_data->write_text_max; + break; + } + case SEND_EMPTY_IF_NULL: + ok(!lstrcmpA(*text, empty_a), "Code 0x%08x test 0x%08x sub test %d expect empty text, got %s\n", + notify_test_info.unicode, notify_test_info.test_id, notify_test_info.sub_test_id, *text); + break; + case DONT_SEND_EMPTY_IF_NULL: + ok(!*text, "Code 0x%08x test 0x%08x sub test %d expect null text\n", notify_test_info.unicode, + notify_test_info.test_id, notify_test_info.sub_test_id); + break; + } +} + +static LRESULT WINAPI test_notify_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) +{ + static const WCHAR test[] = {'t', 'e', 's', 't', 0}; + switch (message) + { + case WM_NOTIFY: + { + NMHDR *hdr = (NMHDR *)lParam; + + /* Not notifications we want to test */ + if (!notify_test_info.unicode) break; + ok(!notify_test_info.received, "Extra notification received\n"); + + ok(wParam == notify_test_info.id_from, "Expect %ld, got %ld\n", notify_test_info.id_from, wParam); + ok(hdr->code == notify_test_info.ansi, "Expect 0x%08x, got 0x%08x\n", notify_test_info.ansi, hdr->code); + ok(hdr->idFrom == notify_test_info.id_from, "Expect %ld, got %ld\n", notify_test_info.id_from, wParam); + ok(hdr->hwndFrom == notify_test_info.hwnd_from, "Expect %p, got %p\n", notify_test_info.hwnd_from, hdr->hwndFrom); + + if (hdr->code != notify_test_info.ansi) + { + skip("Notification code mismatch, skipping lParam check\n"); + return 0; + } + switch (hdr->code) + { + /* Toolbar */ + case TBN_SAVE: + { + NMTBSAVE *nmtbs = (NMTBSAVE *)hdr; + notify_generic_text_handler((CHAR **)&nmtbs->tbButton.iString, NULL); + break; + } + case TBN_RESTORE: + { + NMTBRESTORE *nmtbr = (NMTBRESTORE *)hdr; + notify_generic_text_handler((CHAR **)&nmtbr->tbButton.iString, NULL); + break; + } + case TBN_GETBUTTONINFOA: + { + NMTOOLBARA *nmtb = (NMTOOLBARA *)hdr; + notify_generic_text_handler(&nmtb->pszText, &nmtb->cchText); + break; + } + case TBN_GETDISPINFOW: + { + NMTBDISPINFOW *nmtbdi = (NMTBDISPINFOW *)hdr; + notify_generic_text_handler((CHAR **)&nmtbdi->pszText, &nmtbdi->cchText); + break; + } + case TBN_GETINFOTIPA: + { + NMTBGETINFOTIPA *nmtbgit = (NMTBGETINFOTIPA *)hdr; + notify_generic_text_handler(&nmtbgit->pszText, &nmtbgit->cchTextMax); + break; + } + default: + ok(0, "Unexpected message 0x%08x\n", hdr->code); + } + notify_test_info.received = TRUE; + ok(!lstrcmpA(test_a, "test"), "test_a got modified\n"); + ok(!lstrcmpW(test_w, test), "test_w got modified\n"); + return 0; + } + case WM_NOTIFYFORMAT: + if (lParam == NF_QUERY) return NFR_ANSI; + break; + } + return DefWindowProcA(hwnd, message, wParam, lParam); +} + +static BOOL register_test_notify_class(void) +{ + WNDCLASSA cls = {0}; + + cls.lpfnWndProc = test_notify_proc; + cls.hInstance = GetModuleHandleA(NULL); + cls.lpszClassName = "Pager notify class"; + return RegisterClassA(&cls); +} + +static void send_notify(HWND pager, UINT unicode, UINT ansi, LPARAM lParam, BOOL code_change) +{ + NMHDR *hdr = (NMHDR *)lParam; + + notify_test_info.unicode = unicode; + notify_test_info.id_from = 1; + notify_test_info.hwnd_from = child1_wnd; + notify_test_info.ansi = ansi; + notify_test_info.received = FALSE; + + hdr->code = unicode; + hdr->idFrom = 1; + hdr->hwndFrom = child1_wnd; + + SendMessageW(pager, WM_NOTIFY, hdr->idFrom, lParam); + ok(notify_test_info.received, "Expect notification received\n"); + ok(hdr->code == code_change ? ansi : unicode, "Expect 0x%08x, got 0x%08x\n", hdr->code, + code_change ? ansi : unicode); +} + +/* Send notify to test text field conversion. In parent proc notify_generic_text_handler() handles these messages */ +static void test_notify_generic_text_helper(HWND pager, const struct generic_text_helper_para *para) +{ + const struct notify_test_send *send_data; + const struct notify_test_receive *receive_data; + INT array_size; + INT i; + + notify_test_info.flags = para->flags; + + if (para->flags & (CONVERT_SEND | DONT_CONVERT_SEND)) + { + if (para->flags & CONVERT_SEND) + { + notify_test_info.test_id = CONVERT_SEND; + send_data = test_convert_send_data; + array_size = ARRAY_SIZE(test_convert_send_data); + } + else + { + notify_test_info.test_id = DONT_CONVERT_SEND; + send_data = test_dont_convert_send_data; + array_size = ARRAY_SIZE(test_dont_convert_send_data); + } + + for (i = 0; i < array_size; i++) + { + const struct notify_test_send *data = send_data + i; + notify_test_info.sub_test_id = i; + + memset(para->ptr, 0, para->size); + if (para->mask) *para->mask = para->required_mask; + if (data->send_text) + { + memcpy(buffer, data->send_text, data->send_text_size); + *para->text = buffer; + } + if (para->text_max) *para->text_max = data->send_text_max; + send_notify(pager, para->code_unicode, para->code_ansi, (LPARAM)para->ptr, TRUE); + } + } + + if (para->flags & (CONVERT_RECEIVE | DONT_CONVERT_RECEIVE)) + { + if (para->flags & CONVERT_RECEIVE) + { + notify_test_info.test_id = CONVERT_RECEIVE; + receive_data = test_convert_receive_data; + array_size = ARRAY_SIZE(test_convert_receive_data); + } + else + { + notify_test_info.test_id = DONT_CONVERT_RECEIVE; + receive_data = test_dont_convert_receive_data; + array_size = ARRAY_SIZE(test_dont_convert_receive_data); + } + + for (i = 0; i < array_size; i++) + { + const struct notify_test_receive *data = receive_data + i; + notify_test_info.sub_test_id = i; + + memset(para->ptr, 0, para->size); + if (para->mask) *para->mask = para->required_mask; + if (data->send_text) + { + memcpy(buffer, data->send_text, data->send_text_size); + *para->text = buffer; + } + if (para->text_max) *para->text_max = data->send_text_max; + send_notify(pager, para->code_unicode, para->code_ansi, (LPARAM)para->ptr, TRUE); + if (data->return_text) + { + if (para->flags & CONVERT_RECEIVE) + ok(!lstrcmpW(data->return_text, *para->text), "Code 0x%08x sub test %d expect %s, got %s\n", + para->code_unicode, i, wine_dbgstr_w((WCHAR *)data->return_text), wine_dbgstr_w(*para->text)); + else + ok(!lstrcmpA(data->return_text, (CHAR *)*para->text), "Code 0x%08x sub test %d expect %s, got %s\n", + para->code_unicode, i, (CHAR *)data->return_text, (CHAR *)*para->text); + } + if (para->text_max) + ok(data->return_text_max == *para->text_max, "Code 0x%08x sub test %d expect %d, got %d\n", + para->code_unicode, i, data->return_text_max, *para->text_max); + } + } + + /* Extra tests for other behavior flags that are not worth it to create their own test arrays */ + memset(para->ptr, 0, para->size); + if (para->mask) *para->mask = para->required_mask; + if (para->text_max) *para->text_max = 1; + if (para->flags & SEND_EMPTY_IF_NULL) + notify_test_info.test_id = SEND_EMPTY_IF_NULL; + else + notify_test_info.test_id = DONT_SEND_EMPTY_IF_NULL; + send_notify(pager, para->code_unicode, para->code_ansi, (LPARAM)para->ptr, TRUE); +} + +static void test_wm_notify(void) +{ + static const CHAR *class = "Pager notify class"; + HWND parent, pager; + /* Tool Bar */ + static NMTBRESTORE nmtbr; + static NMTBSAVE nmtbs; + static NMTOOLBARW nmtb; + static NMTBDISPINFOW nmtbdi; + static NMTBGETINFOTIPW nmtbgit; + static const struct generic_text_helper_para paras[] = + { + /* Tool Bar */ + {&nmtbs, sizeof(nmtbs), NULL, 0, (WCHAR **)&nmtbs.tbButton.iString, NULL, TBN_SAVE, TBN_SAVE, + DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE}, + {&nmtbr, sizeof(nmtbr), NULL, 0, (WCHAR **)&nmtbr.tbButton.iString, NULL, TBN_RESTORE, TBN_RESTORE, + DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE}, + {&nmtbdi, sizeof(nmtbdi), &nmtbdi.dwMask, TBNF_TEXT, &nmtbdi.pszText, &nmtbdi.cchText, TBN_GETDISPINFOW, + TBN_GETDISPINFOW, DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE}, + {&nmtb, sizeof(nmtb), NULL, 0, &nmtb.pszText, &nmtb.cchText, TBN_GETBUTTONINFOW, TBN_GETBUTTONINFOA, + SEND_EMPTY_IF_NULL | CONVERT_SEND | CONVERT_RECEIVE}, + {&nmtbgit, sizeof(nmtbgit), NULL, 0, &nmtbgit.pszText, &nmtbgit.cchTextMax, TBN_GETINFOTIPW, TBN_GETINFOTIPA, + DONT_CONVERT_SEND | CONVERT_RECEIVE} + }; + INT i; + + ok(register_test_notify_class(), "Register test class failed, error 0x%08x\n", GetLastError()); + + parent = CreateWindowA(class, "parent", WS_OVERLAPPED, 0, 0, 100, 100, 0, 0, GetModuleHandleA(0), 0); + ok(parent != NULL, "CreateWindow failed\n"); + pager = CreateWindowA(WC_PAGESCROLLERA, "pager", WS_CHILD, 0, 0, 100, 100, parent, 0, GetModuleHandleA(0), 0); + ok(pager != NULL, "CreateWindow failed\n"); + child1_wnd = CreateWindowA(class, "child", WS_CHILD, 0, 0, 100, 100, pager, (HMENU)1, GetModuleHandleA(0), 0); + ok(child1_wnd != NULL, "CreateWindow failed\n"); + SendMessageW(pager, PGM_SETCHILD, 0, (LPARAM)child1_wnd); + + for (i = 0; i < ARRAY_SIZE(paras); i++) + test_notify_generic_text_helper(pager, paras + i); + + DestroyWindow(parent); + UnregisterClassA(class, GetModuleHandleA(NULL)); +} + static void init_functions(void) { HMODULE mod = LoadLibraryA("comctl32.dll"); @@ -447,6 +844,7 @@ START_TEST(pager) test_pager(); test_wm_notifyformat(); + test_wm_notify(); DestroyWindow(parent_wnd); } -- 2.18.0

2 1

[PATCH] dwrite/layout: Test resulting line width before adding inline trimming run.
by Nikolay Sivov 21 Sep '18

21 Sep '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- This fixes out-of-bounds read in cluster array, for example when trimming is applied to single cluster layout. dlls/dwrite/layout.c | 3 +++ dlls/dwrite/tests/layout.c | 43 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 46 insertions(+) diff --git a/dlls/dwrite/layout.c b/dlls/dwrite/layout.c index 10d591457c..5deae455b1 100644 --- a/dlls/dwrite/layout.c +++ b/dlls/dwrite/layout.c @@ -1926,6 +1926,9 @@ static void layout_add_line(struct dwrite_textlayout *layout, UINT32 first_clust if (FAILED(hr)) return; + if (get_cluster_range_width(layout, start, i) + sign_metrics.width > layout->metrics.layoutWidth) + append_trimming_run = FALSE; + if (append_trimming_run) { struct layout_effective_inline *trimming_sign; diff --git a/dlls/dwrite/tests/layout.c b/dlls/dwrite/tests/layout.c index 652f6b78ac..c77a0ea51b 100644 --- a/dlls/dwrite/tests/layout.c +++ b/dlls/dwrite/tests/layout.c @@ -1636,6 +1636,11 @@ static const struct drawcall_entry draw_seq[] = { { DRAW_LAST_KIND } }; +static const struct drawcall_entry draw_trimmed_seq[] = { + { DRAW_GLYPHRUN, {'a',0}, {'e','n','-','u','s',0}, 1 }, + { DRAW_LAST_KIND } +}; + static const struct drawcall_entry draw_seq2[] = { { DRAW_GLYPHRUN, {'s',0}, {'r','u',0}, 1 }, { DRAW_GLYPHRUN, {'t',0}, {'r','u',0}, 1 }, @@ -2386,6 +2391,44 @@ todo_wine IDWriteTextLayout_Release(layout); + /* Single cluster layout, trigger trimming. */ + hr = IDWriteFactory_CreateTextLayout(factory, str6W, 1, format, 1000.0f, 200.0f, &layout); + ok(hr == S_OK, "Failed to create layout, hr %#x.\n", hr); + + count = 0; + memset(metrics, 0, sizeof(metrics)); + hr = IDWriteTextLayout_GetClusterMetrics(layout, metrics, 1, &count); + ok(hr == S_OK, "Failed to get cluster metrics, hr %#x.\n", hr); + ok(count == 1, "Unexpected cluster count %u.\n", count); + + hr = IDWriteTextLayout_SetMaxWidth(layout, metrics[0].width / 2.0f); + ok(hr == S_OK, "Failed to set layout width, hr %#x.\n", hr); + + trimming_options.granularity = DWRITE_TRIMMING_GRANULARITY_CHARACTER; + trimming_options.delimiter = 0; + trimming_options.delimiterCount = 0; + hr = IDWriteTextLayout_SetTrimming(layout, &trimming_options, trimm); + ok(hr == S_OK, "Failed to set trimming options, hr %#x.\n", hr); + + count = 0; + memset(metrics, 0, sizeof(metrics)); + hr = IDWriteTextLayout_GetClusterMetrics(layout, metrics, 1, &count); + ok(hr == S_OK, "Failed to get cluster metrics, hr %#x.\n", hr); + ok(count == 1, "Unexpected cluster count %u.\n", count); + + hr = IDWriteTextLayout_GetLineMetrics(layout, &line, 1, &count); + ok(hr == S_OK, "Failed to get line metrics, hr %#x.\n", hr); + ok(count == 1, "Unexpected line count %u.\n", count); + ok(line.length == 1, "Unexpected line length %u.\n", line.length); + ok(line.isTrimmed, "Unexpected trimming flag %x.\n", line.isTrimmed); + + flush_sequence(sequences, RENDERER_ID); + hr = IDWriteTextLayout_Draw(layout, NULL, &testrenderer, 0.0f, 0.0f); + ok(hr == S_OK, "Draw() failed, hr %#x.\n", hr); + ok_sequence(sequences, RENDERER_ID, draw_trimmed_seq, "Trimmed draw test", FALSE); + + IDWriteTextLayout_Release(layout); + IDWriteInlineObject_Release(trimm); IDWriteTextFormat_Release(format); IDWriteFactory_Release(factory); -- 2.18.0

1 0

[PATCH 2/2] wined3d: Move the OpenGL view class to struct wined3d_format_gl.
by Henri Verbeet 21 Sep '18

21 Sep '18

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/utils.c | 16 ++++++++-------- dlls/wined3d/view.c | 11 +++++++++-- dlls/wined3d/wined3d_private.h | 3 ++- 3 files changed, 19 insertions(+), 11 deletions(-) diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 45d1f07b39c..8e9b6dfafd6 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -2991,23 +2991,23 @@ static GLenum lookup_gl_view_class(GLenum internal_format) return GL_NONE; } -static void query_view_class(struct wined3d_format *format) +static void query_view_class(struct wined3d_format_gl *format) { GLenum internal_view_class, gamma_view_class, rt_view_class; - internal_view_class = lookup_gl_view_class(format->glInternal); - gamma_view_class = lookup_gl_view_class(format->glGammaInternal); - rt_view_class = lookup_gl_view_class(format->rtInternal); + internal_view_class = lookup_gl_view_class(format->f.glInternal); + gamma_view_class = lookup_gl_view_class(format->f.glGammaInternal); + rt_view_class = lookup_gl_view_class(format->f.rtInternal); if (internal_view_class == gamma_view_class || gamma_view_class == rt_view_class) { - format->gl_view_class = internal_view_class; + format->view_class = internal_view_class; TRACE("Format %s is member of GL view class %#x.\n", - debug_d3dformat(format->id), format->gl_view_class); + debug_d3dformat(format->f.id), format->view_class); } else { - format->gl_view_class = GL_NONE; + format->view_class = GL_NONE; } } @@ -3083,7 +3083,7 @@ static void query_internal_format(struct wined3d_adapter *adapter, } } - query_view_class(format); + query_view_class(wined3d_format_gl_mutable(format)); if (format->glInternal && format->flags[WINED3D_GL_RES_TYPE_RB] & (WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) diff --git a/dlls/wined3d/view.c b/dlls/wined3d/view.c index d1678670bfe..dedb9fc8047 100644 --- a/dlls/wined3d/view.c +++ b/dlls/wined3d/view.c @@ -531,7 +531,11 @@ static void wined3d_render_target_view_cs_init(void *object) if (resource->format->id != view->format->id || (view->layer_count != 1 && view->layer_count != depth_or_layer_count)) { - if (resource->format->gl_view_class != view->format->gl_view_class) + GLenum resource_class, view_class; + + resource_class = wined3d_format_gl(resource->format)->view_class; + view_class = wined3d_format_gl(view->format)->view_class; + if (resource_class != view_class) { FIXME("Render target view not supported, resource format %s, view format %s.\n", debug_d3dformat(resource->format->id), debug_d3dformat(view->format->id)); @@ -722,7 +726,10 @@ static void wined3d_shader_resource_view_cs_init(void *object) else { struct wined3d_texture *texture = texture_from_resource(resource); + GLenum resource_class, view_class; + resource_class = wined3d_format_gl(resource->format)->view_class; + view_class = wined3d_format_gl(view_format)->view_class; view_target = get_texture_view_target(gl_info, desc, texture); if (resource->format->id == view_format->id && texture->target == view_target @@ -737,7 +744,7 @@ static void wined3d_shader_resource_view_cs_init(void *object) FIXME("Swapchain shader resource views not supported.\n"); } else if (resource->format->typeless_id == view_format->typeless_id - && resource->format->gl_view_class == view_format->gl_view_class) + && resource_class == view_class) { create_texture_view(&view->gl_view, view_target, desc, texture, view_format); } diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index e11d61379c2..cb2f44212c4 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -4359,7 +4359,6 @@ struct wined3d_format unsigned int width, unsigned int height, unsigned int depth); enum wined3d_format_id typeless_id; - GLenum gl_view_class; }; const struct wined3d_format *wined3d_get_format(const struct wined3d_adapter *adapter, @@ -4385,6 +4384,8 @@ struct wined3d_format_gl GLenum vtx_type; GLint vtx_format; + + GLenum view_class; }; static inline const struct wined3d_format_gl *wined3d_format_gl(const struct wined3d_format *format) -- 2.11.0

1 0

[PATCH 1/2] wined3d: Move the OpenGL vertex format to a separate structure.
by Henri Verbeet 21 Sep '18

21 Sep '18

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/context.c | 38 +++++++++++++++++++++++++------------- dlls/wined3d/utils.c | 34 +++++++++++++++++++++++++--------- dlls/wined3d/wined3d_private.h | 15 +++++++++++++-- 3 files changed, 63 insertions(+), 24 deletions(-) diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c index 19f0fcbd2b0..167241a6f0f 100644 --- a/dlls/wined3d/context.c +++ b/dlls/wined3d/context.c @@ -5045,6 +5045,7 @@ void context_load_tex_coords(const struct wined3d_context *context, const struct GLuint *current_bo, const struct wined3d_state *state) { const struct wined3d_gl_info *gl_info = context->gl_info; + const struct wined3d_format_gl *format_gl; unsigned int mapped_stage = 0; unsigned int texture_idx; @@ -5079,7 +5080,8 @@ void context_load_tex_coords(const struct wined3d_context *context, const struct checkGLcall("glClientActiveTextureARB"); /* The coords to supply depend completely on the fvf/vertex shader. */ - gl_info->gl_ops.gl.p_glTexCoordPointer(e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride, + format_gl = wined3d_format_gl(e->format); + gl_info->gl_ops.gl.p_glTexCoordPointer(format_gl->vtx_format, format_gl->vtx_type, e->stride, e->data.addr + state->load_base_vertex_index * e->stride); gl_info->gl_ops.gl.p_glEnableClientState(GL_TEXTURE_COORD_ARRAY); } @@ -5121,6 +5123,7 @@ static void context_load_vertex_data(struct wined3d_context *context, { const struct wined3d_gl_info *gl_info = context->gl_info; const struct wined3d_stream_info_element *e; + const struct wined3d_format_gl *format_gl; GLuint current_bo; TRACE("context %p, si %p, state %p.\n", context, si, state); @@ -5151,6 +5154,7 @@ static void context_load_vertex_data(struct wined3d_context *context, if (si->use_map & (1u << WINED3D_FFP_POSITION)) { e = &si->elements[WINED3D_FFP_POSITION]; + format_gl = wined3d_format_gl(e->format); if (current_bo != e->data.buffer_object) { @@ -5160,9 +5164,9 @@ static void context_load_vertex_data(struct wined3d_context *context, } TRACE("glVertexPointer(%#x, %#x, %#x, %p);\n", - e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride, + format_gl->vtx_format, format_gl->vtx_type, e->stride, e->data.addr + state->load_base_vertex_index * e->stride); - gl_info->gl_ops.gl.p_glVertexPointer(e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride, + gl_info->gl_ops.gl.p_glVertexPointer(format_gl->vtx_format, format_gl->vtx_type, e->stride, e->data.addr + state->load_base_vertex_index * e->stride); checkGLcall("glVertexPointer(...)"); gl_info->gl_ops.gl.p_glEnableClientState(GL_VERTEX_ARRAY); @@ -5173,6 +5177,7 @@ static void context_load_vertex_data(struct wined3d_context *context, if (si->use_map & (1u << WINED3D_FFP_NORMAL)) { e = &si->elements[WINED3D_FFP_NORMAL]; + format_gl = wined3d_format_gl(e->format); if (current_bo != e->data.buffer_object) { @@ -5181,9 +5186,9 @@ static void context_load_vertex_data(struct wined3d_context *context, current_bo = e->data.buffer_object; } - TRACE("glNormalPointer(%#x, %#x, %p);\n", e->format->gl_vtx_type, e->stride, + TRACE("glNormalPointer(%#x, %#x, %p);\n", format_gl->vtx_type, e->stride, e->data.addr + state->load_base_vertex_index * e->stride); - gl_info->gl_ops.gl.p_glNormalPointer(e->format->gl_vtx_type, e->stride, + gl_info->gl_ops.gl.p_glNormalPointer(format_gl->vtx_type, e->stride, e->data.addr + state->load_base_vertex_index * e->stride); checkGLcall("glNormalPointer(...)"); gl_info->gl_ops.gl.p_glEnableClientState(GL_NORMAL_ARRAY); @@ -5200,6 +5205,7 @@ static void context_load_vertex_data(struct wined3d_context *context, if (si->use_map & (1u << WINED3D_FFP_DIFFUSE)) { e = &si->elements[WINED3D_FFP_DIFFUSE]; + format_gl = wined3d_format_gl(e->format); if (current_bo != e->data.buffer_object) { @@ -5209,9 +5215,9 @@ static void context_load_vertex_data(struct wined3d_context *context, } TRACE("glColorPointer(%#x, %#x %#x, %p);\n", - e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride, + format_gl->vtx_format, format_gl->vtx_type, e->stride, e->data.addr + state->load_base_vertex_index * e->stride); - gl_info->gl_ops.gl.p_glColorPointer(e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride, + gl_info->gl_ops.gl.p_glColorPointer(format_gl->vtx_format, format_gl->vtx_type, e->stride, e->data.addr + state->load_base_vertex_index * e->stride); checkGLcall("glColorPointer(4, GL_UNSIGNED_BYTE, ...)"); gl_info->gl_ops.gl.p_glEnableClientState(GL_COLOR_ARRAY); @@ -5233,8 +5239,12 @@ static void context_load_vertex_data(struct wined3d_context *context, if (gl_info->supported[EXT_SECONDARY_COLOR]) { - GLenum type = e->format->gl_vtx_type; - GLint format = e->format->gl_vtx_format; + GLint format; + GLenum type; + + format_gl = wined3d_format_gl(e->format); + type = format_gl->vtx_type; + format = format_gl->vtx_format; if (current_bo != e->data.buffer_object) { @@ -5342,6 +5352,7 @@ static void context_load_numbered_arrays(struct wined3d_context *context, { const struct wined3d_stream_info_element *element = &stream_info->elements[i]; const struct wined3d_stream_state *stream; + const struct wined3d_format_gl *format_gl; if (!(stream_info->use_map & (1u << i))) { @@ -5354,6 +5365,7 @@ static void context_load_numbered_arrays(struct wined3d_context *context, continue; } + format_gl = wined3d_format_gl(element->format); stream = &state->streams[element->stream_idx]; if ((stream->flags & WINED3DSTREAMSOURCE_INSTANCEDATA) && !context->instance_count) @@ -5376,7 +5388,7 @@ static void context_load_numbered_arrays(struct wined3d_context *context, if (element->stride) { - DWORD format_flags = element->format->flags[WINED3D_GL_RES_TYPE_BUFFER]; + DWORD format_flags = format_gl->f.flags[WINED3D_GL_RES_TYPE_BUFFER]; if (current_bo != element->data.buffer_object) { @@ -5390,12 +5402,12 @@ static void context_load_numbered_arrays(struct wined3d_context *context, * won't be load converted attributes anyway. */ if (vs && vs->reg_maps.shader_version.major >= 4 && (format_flags & WINED3DFMT_FLAG_INTEGER)) { - GL_EXTCALL(glVertexAttribIPointer(i, element->format->gl_vtx_format, element->format->gl_vtx_type, + GL_EXTCALL(glVertexAttribIPointer(i, format_gl->vtx_format, format_gl->vtx_type, element->stride, element->data.addr + state->load_base_vertex_index * element->stride)); } else { - GL_EXTCALL(glVertexAttribPointer(i, element->format->gl_vtx_format, element->format->gl_vtx_type, + GL_EXTCALL(glVertexAttribPointer(i, format_gl->vtx_format, format_gl->vtx_type, !!(format_flags & WINED3DFMT_FLAG_NORMALISED), element->stride, element->data.addr + state->load_base_vertex_index * element->stride)); } @@ -5419,7 +5431,7 @@ static void context_load_numbered_arrays(struct wined3d_context *context, if (context->numbered_array_mask & (1u << i)) context_unload_numbered_array(context, i); - switch (element->format->id) + switch (format_gl->f.id) { case WINED3DFMT_R32_FLOAT: GL_EXTCALL(glVertexAttrib1fv(i, (const GLfloat *)ptr)); diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index bf32953032e..45d1f07b39c 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -1925,6 +1925,11 @@ static inline int get_format_idx(enum wined3d_format_id format_id) return -1; } +static struct wined3d_format_gl *wined3d_format_gl_mutable(struct wined3d_format *format) +{ + return CONTAINING_RECORD(format, struct wined3d_format_gl, f); +} + static struct wined3d_format *get_format_by_idx(const struct wined3d_adapter *adapter, int fmt_idx) { return (struct wined3d_format *)((BYTE *)adapter->formats + fmt_idx * adapter->format_size); @@ -1944,6 +1949,17 @@ static struct wined3d_format *get_format_internal(const struct wined3d_adapter * return get_format_by_idx(adapter, fmt_idx); } +static struct wined3d_format_gl *get_format_gl_internal(const struct wined3d_adapter *adapter, + enum wined3d_format_id format_id) +{ + struct wined3d_format *format; + + if ((format = get_format_internal(adapter, format_id))) + return wined3d_format_gl_mutable(format); + + return NULL; +} + static void copy_format(const struct wined3d_adapter *adapter, struct wined3d_format *dst_format, const struct wined3d_format *src_format) { @@ -3665,27 +3681,27 @@ static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_ static BOOL init_format_vertex_info(const struct wined3d_adapter *adapter, struct wined3d_gl_info *gl_info) { - struct wined3d_format *format; + struct wined3d_format_gl *format; unsigned int i; for (i = 0; i < ARRAY_SIZE(format_vertex_info); ++i) { - if (!(format = get_format_internal(adapter, format_vertex_info[i].id))) + if (!(format = get_format_gl_internal(adapter, format_vertex_info[i].id))) return FALSE; if (!gl_info->supported[format_vertex_info[i].extension]) continue; - format->emit_idx = format_vertex_info[i].emit_idx; - format->gl_vtx_type = format_vertex_info[i].gl_vtx_type; - format->gl_vtx_format = format->component_count; - format->flags[WINED3D_GL_RES_TYPE_BUFFER] |= WINED3DFMT_FLAG_VERTEX_ATTRIBUTE; + format->f.emit_idx = format_vertex_info[i].emit_idx; + format->vtx_type = format_vertex_info[i].gl_vtx_type; + format->vtx_format = format->f.component_count; + format->f.flags[WINED3D_GL_RES_TYPE_BUFFER] |= WINED3DFMT_FLAG_VERTEX_ATTRIBUTE; } if (gl_info->supported[ARB_VERTEX_ARRAY_BGRA]) { - format = get_format_internal(adapter, WINED3DFMT_B8G8R8A8_UNORM); - format->gl_vtx_format = GL_BGRA; + format = get_format_gl_internal(adapter, WINED3DFMT_B8G8R8A8_UNORM); + format->vtx_format = GL_BGRA; } return TRUE; @@ -3968,7 +3984,7 @@ BOOL wined3d_adapter_gl_init_format_info(struct wined3d_adapter *adapter, struct { struct wined3d_gl_info *gl_info = &adapter->gl_info; - if (!wined3d_adapter_init_format_info(adapter, sizeof(struct wined3d_format))) + if (!wined3d_adapter_init_format_info(adapter, sizeof(struct wined3d_format_gl))) return FALSE; if (!init_format_texture_info(adapter, gl_info)) goto fail; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 637c7218c18..e11d61379c2 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -4336,8 +4336,6 @@ struct wined3d_format UINT block_byte_count; enum wined3d_ffp_emit_idx emit_idx; - GLenum gl_vtx_type; - GLint gl_vtx_format; GLint glInternal; GLint glGammaInternal; @@ -4381,6 +4379,19 @@ const struct wined3d_color_key_conversion * wined3d_format_get_color_key_convers BOOL wined3d_formats_are_srgb_variants(enum wined3d_format_id format1, enum wined3d_format_id format2) DECLSPEC_HIDDEN; +struct wined3d_format_gl +{ + struct wined3d_format f; + + GLenum vtx_type; + GLint vtx_format; +}; + +static inline const struct wined3d_format_gl *wined3d_format_gl(const struct wined3d_format *format) +{ + return CONTAINING_RECORD(format, struct wined3d_format_gl, f); +} + BOOL wined3d_array_reserve(void **elements, SIZE_T *capacity, SIZE_T count, SIZE_T size) DECLSPEC_HIDDEN; static inline BOOL wined3d_format_is_typeless(const struct wined3d_format *format) -- 2.11.0

1 0

[PATCH v2] gdi32: Avoid using GCC's typeof extension
by Alex Henrie 21 Sep '18

21 Sep '18

Signed-off-by: Alex Henrie <alexhenrie24(a)gmail.com> --- dlls/gdi32/driver.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/dlls/gdi32/driver.c b/dlls/gdi32/driver.c index ce60d110d9..8920b73f59 100644 --- a/dlls/gdi32/driver.c +++ b/dlls/gdi32/driver.c @@ -61,9 +61,9 @@ static CRITICAL_SECTION_DEBUG critsect_debug = }; static CRITICAL_SECTION driver_section = { &critsect_debug, -1, 0, 0, 0, 0 }; -static typeof(GetDesktopWindow) *pGetDesktopWindow; -static typeof(GetSystemMetrics) *pGetSystemMetrics; -static typeof(SetThreadDpiAwarenessContext) *pSetThreadDpiAwarenessContext; +static HWND (WINAPI *pGetDesktopWindow)(void); +static INT (WINAPI *pGetSystemMetrics)(INT); +static DPI_AWARENESS_CONTEXT (WINAPI *pSetThreadDpiAwarenessContext)(DPI_AWARENESS_CONTEXT); /********************************************************************** * create_driver -- 2.19.0

2 1

[PATCH 1/4] testbot: Add a ModuleBuild check in GetPatchImpacts().
by Francois Gouget 21 Sep '18

21 Sep '18

Patches that impact a single module can impact the Wine files list too. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- testbot/lib/WineTestBot/PatchUtils.pm | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/testbot/lib/WineTestBot/PatchUtils.pm b/testbot/lib/WineTestBot/PatchUtils.pm index 9e0e68980..602c80b7d 100644 --- a/testbot/lib/WineTestBot/PatchUtils.pm +++ b/testbot/lib/WineTestBot/PatchUtils.pm @@ -279,7 +279,8 @@ sub GetPatchImpacts($;$) if ($PastImpacts) { - if ($PastImpacts->{WineBuild} or $PastImpacts->{TestBuild}) + if ($PastImpacts->{WineBuild} or $PastImpacts->{ModuleBuild} or + $PastImpacts->{TestBuild}) { # Update the list of Wine files so we correctly recognize patchset parts # that modify new Wine files. -- 2.18.0

1 3

[PATCH] xmllite/writer: Fix writing prefixed attributes.
by Nikolay Sivov 21 Sep '18

21 Sep '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/xmllite/tests/writer.c | 27 +++++++++++++++++++++++++++ dlls/xmllite/writer.c | 8 +++++--- 2 files changed, 32 insertions(+), 3 deletions(-) diff --git a/dlls/xmllite/tests/writer.c b/dlls/xmllite/tests/writer.c index 2cd9cea6cc..5ddb1ef2a7 100644 --- a/dlls/xmllite/tests/writer.c +++ b/dlls/xmllite/tests/writer.c @@ -1768,6 +1768,33 @@ todo_wine "</p:a>"); IStream_Release(stream); + + /* Define prefix, write attribute with it. */ + stream = writer_set_output(writer); + + hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Omit); + ok(hr == S_OK, "got 0x%08x\n", hr); + + hr = write_start_element(writer, NULL, "e", NULL); + ok(hr == S_OK, "got 0x%08x\n", hr); + + hr = write_attribute_string(writer, "xmlns", "prefix", NULL, "uri"); + ok(hr == S_OK, "got 0x%08x\n", hr); + + hr = write_attribute_string(writer, "prefix", "attr", NULL, "value"); + ok(hr == S_OK, "got 0x%08x\n", hr); + + hr = IXmlWriter_WriteEndDocument(writer); + ok(hr == S_OK, "got 0x%08x\n", hr); + + hr = IXmlWriter_Flush(writer); + ok(hr == S_OK, "got 0x%08x\n", hr); + + CHECK_OUTPUT(stream, + "<e xmlns:prefix=\"uri\" prefix:attr=\"value\" />"); + + IStream_Release(stream); + IXmlWriter_Release(writer); } diff --git a/dlls/xmllite/writer.c b/dlls/xmllite/writer.c index bf2a7514ac..8d1fb3a2da 100644 --- a/dlls/xmllite/writer.c +++ b/dlls/xmllite/writer.c @@ -843,8 +843,8 @@ static HRESULT WINAPI xmlwriter_WriteAttributeString(IXmlWriter *iface, LPCWSTR static const WCHAR xmlnsW[] = {'x','m','l','n','s',0}; static const WCHAR xmlW[] = {'x','m','l',0}; xmlwriter *This = impl_from_IXmlWriter(iface); + BOOL is_xmlns_prefix, is_xmlns_local; int prefix_len, local_len; - BOOL is_xmlns_prefix; struct ns *ns; HRESULT hr; @@ -879,6 +879,8 @@ static HRESULT WINAPI xmlwriter_WriteAttributeString(IXmlWriter *iface, LPCWSTR if (FAILED(hr = is_valid_ncname(local, &local_len))) return hr; + is_xmlns_local = !strcmpW(local, xmlnsW); + /* Trivial case, no prefix. */ if (prefix_len == 0 && is_empty_string(uri)) { @@ -918,9 +920,9 @@ static HRESULT WINAPI xmlwriter_WriteAttributeString(IXmlWriter *iface, LPCWSTR } /* Ignore prefix is URI wasn't specified. */ - if (is_empty_string(uri)) + if (is_xmlns_local && is_empty_string(uri)) { - write_output_attribute(This, NULL, 0, local, local_len, value); + write_output_attribute(This, NULL, 0, xmlnsW, ARRAY_SIZE(xmlnsW) - 1, value); return S_OK; } -- 2.18.0

1 0

[PATCH 1/3] opcservices: Add content type entry for relationship parts.
by Nikolay Sivov 21 Sep '18

21 Sep '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/opcservices/package.c | 70 +++++++++++++++++++++++++++++++++----- 1 file changed, 62 insertions(+), 8 deletions(-) diff --git a/dlls/opcservices/package.c b/dlls/opcservices/package.c index d7467a5ef8..a6f3b9046d 100644 --- a/dlls/opcservices/package.c +++ b/dlls/opcservices/package.c @@ -1535,6 +1535,7 @@ HRESULT opc_package_create(IOpcFactory *factory, IOpcPackage **out) struct content_types { struct list types; + BOOL has_rels_part; }; enum content_type_element @@ -1653,9 +1654,26 @@ static HRESULT opc_package_add_content_type(struct content_types *types, IOpcPar return hr; } +static BOOL opc_package_has_rels_part(IOpcRelationshipSet *rel_set) +{ + IOpcRelationshipEnumerator *enumerator; + BOOL has_next; + HRESULT hr; + + if (FAILED(hr = IOpcRelationshipSet_GetEnumerator(rel_set, &enumerator))) + return FALSE; + + has_next = FALSE; + IOpcRelationshipEnumerator_MoveNext(enumerator, &has_next); + IOpcRelationshipEnumerator_Release(enumerator); + + return has_next; +} + static HRESULT opc_package_collect_content_types(IOpcPackage *package, struct content_types *types) { IOpcPartEnumerator *enumerator; + IOpcRelationshipSet *rel_set; IOpcPartSet *parts; BOOL has_next; HRESULT hr; @@ -1663,6 +1681,13 @@ static HRESULT opc_package_collect_content_types(IOpcPackage *package, struct co if (FAILED(hr = IOpcPackage_GetPartSet(package, &parts))) return hr; + hr = IOpcPackage_GetRelationshipSet(package, &rel_set); + if (SUCCEEDED(hr)) + { + types->has_rels_part |= opc_package_has_rels_part(rel_set); + IOpcRelationshipSet_Release(rel_set); + } + hr = IOpcPartSet_GetEnumerator(parts, &enumerator); IOpcPartSet_Release(parts); if (FAILED(hr)) @@ -1681,6 +1706,16 @@ static HRESULT opc_package_collect_content_types(IOpcPackage *package, struct co if (FAILED(hr = IOpcPartEnumerator_GetCurrent(enumerator, &part))) break; + if (!types->has_rels_part) + { + hr = IOpcPart_GetRelationshipSet(part, &rel_set); + if (SUCCEEDED(hr)) + { + types->has_rels_part |= opc_package_has_rels_part(rel_set); + IOpcRelationshipSet_Release(rel_set); + } + } + hr = opc_package_add_content_type(types, part); IOpcPart_Release(part); if (FAILED(hr)) @@ -1694,23 +1729,40 @@ static HRESULT opc_package_collect_content_types(IOpcPackage *package, struct co return hr; } +static HRESULT opc_package_write_default_type(const WCHAR *ext, const WCHAR *type, IXmlWriter *writer) +{ + static const WCHAR contenttypeW[] = {'C','o','n','t','e','n','t','T','y','p','e',0}; + static const WCHAR extensionW[] = {'E','x','t','e','n','s','i','o','n',0}; + static const WCHAR defaultW[] = {'D','e','f','a','u','l','t',0}; + HRESULT hr; + + hr = IXmlWriter_WriteStartElement(writer, NULL, defaultW, NULL); + if (SUCCEEDED(hr)) + hr = IXmlWriter_WriteAttributeString(writer, NULL, extensionW, NULL, ext); + if (SUCCEEDED(hr)) + hr = IXmlWriter_WriteAttributeString(writer, NULL, contenttypeW, NULL, type); + return hr; +} + static HRESULT opc_package_write_contenttypes(IOpcPackage *package, struct zip_archive *archive, IXmlWriter *writer) { static const WCHAR uriW[] = {'h','t','t','p',':','/','/','s','c','h','e','m','a','s','.','o','p','e','n','x','m','l','f','o','r','m','a','t','s','.','o','r','g','/', 'p','a','c','k','a','g','e','/','2','0','0','6','/','c','o','n','t','e','n','t','-','t','y','p','e','s',0}; + static const WCHAR relstypeW[] = {'a','p','p','l','i','c','a','t','i','o','n','/','v','n','d','.','o','p','e','n','x','m','l','f','o','r','m','a','t','s','-', + 'p','a','c','k','a','g','e','.','r','e','l','a','t','i','o','n','s','h','i','p','s','+','x','m','l',0}; static const WCHAR contenttypesW[] = {'[','C','o','n','t','e','n','t','_','T','y','p','e','s',']','.','x','m','l',0}; static const WCHAR contenttypeW[] = {'C','o','n','t','e','n','t','T','y','p','e',0}; - static const WCHAR extensionW[] = {'E','x','t','e','n','s','i','o','n',0}; static const WCHAR overrideW[] = {'O','v','e','r','r','i','d','e',0}; static const WCHAR partnameW[] = {'P','a','r','t','N','a','m','e',0}; - static const WCHAR defaultW[] = {'D','e','f','a','u','l','t',0}; static const WCHAR typesW[] = {'T','y','p','e','s',0}; + static const WCHAR relsW[] = {'r','e','l','s',0}; struct content_type *content_type, *content_type2; struct content_types types; IStream *content = NULL; HRESULT hr; list_init(&types.types); + types.has_rels_part = FALSE; hr = CreateStreamOnHGlobal(NULL, TRUE, &content); if (SUCCEEDED(hr)) @@ -1722,16 +1774,18 @@ static HRESULT opc_package_write_contenttypes(IOpcPackage *package, struct zip_a if (SUCCEEDED(hr)) hr = IXmlWriter_WriteStartElement(writer, NULL, typesW, uriW); + if (SUCCEEDED(hr) && types.has_rels_part) + { + hr = opc_package_write_default_type(relsW, relstypeW, writer); + if (SUCCEEDED(hr)) + hr = IXmlWriter_WriteEndElement(writer); + } + LIST_FOR_EACH_ENTRY_SAFE(content_type, content_type2, &types.types, struct content_type, entry) { if (content_type->element == CONTENT_TYPE_DEFAULT) { - if (SUCCEEDED(hr)) - hr = IXmlWriter_WriteStartElement(writer, NULL, defaultW, NULL); - if (SUCCEEDED(hr)) - hr = IXmlWriter_WriteAttributeString(writer, NULL, extensionW, NULL, content_type->u.def.ext + 1); - if (SUCCEEDED(hr)) - hr = IXmlWriter_WriteAttributeString(writer, NULL, contenttypeW, NULL, content_type->u.def.type); + hr = opc_package_write_default_type(content_type->u.def.ext + 1, content_type->u.def.type, writer); CoTaskMemFree(content_type->u.def.ext); CoTaskMemFree(content_type->u.def.type); -- 2.18.0

1 2

[PATCH] shlwapi: Avoid ARRAY_SIZE-like macros
by Michael Stefaniuc 21 Sep '18

21 Sep '18

Signed-off-by: Michael Stefaniuc <mstefani(a)winehq.org> --- dlls/shlwapi/path.c | 10 ++++------ dlls/shlwapi/reg.c | 7 +++---- dlls/shlwapi/url.c | 2 +- 3 files changed, 8 insertions(+), 11 deletions(-) diff --git a/dlls/shlwapi/path.c b/dlls/shlwapi/path.c index ae05381b66..e24835f238 100644 --- a/dlls/shlwapi/path.c +++ b/dlls/shlwapi/path.c @@ -4217,8 +4217,6 @@ HRESULT WINAPI SHGetWebFolderFilePathW(LPCWSTR lpszFile, LPWSTR lpszPath, DWORD { static const WCHAR szWeb[] = {'\\','W','e','b','\\','\0'}; static const WCHAR szWebMui[] = {'m','u','i','\\','%','0','4','x','\\','\0'}; -#define szWebLen (sizeof(szWeb)/sizeof(WCHAR)) -#define szWebMuiLen ((sizeof(szWebMui)+1)/sizeof(WCHAR)) DWORD dwLen, dwFileLen; LANGID lidSystem, lidUser; @@ -4231,11 +4229,11 @@ HRESULT WINAPI SHGetWebFolderFilePathW(LPCWSTR lpszFile, LPWSTR lpszPath, DWORD dwFileLen = strlenW(lpszFile); - if (dwLen + dwFileLen + szWebLen >= dwPathLen) + if (dwLen + dwFileLen + ARRAY_SIZE(szWeb) >= dwPathLen) return E_FAIL; /* lpszPath too short */ strcpyW(lpszPath+dwLen, szWeb); - dwLen += szWebLen; + dwLen += ARRAY_SIZE(szWeb); dwPathLen = dwPathLen - dwLen; /* Remaining space */ lidSystem = GetSystemDefaultUILanguage(); @@ -4243,11 +4241,11 @@ HRESULT WINAPI SHGetWebFolderFilePathW(LPCWSTR lpszFile, LPWSTR lpszPath, DWORD if (lidSystem != lidUser) { - if (dwFileLen + szWebMuiLen < dwPathLen) + if (dwFileLen + ARRAY_SIZE(szWebMui) < dwPathLen) { /* Use localised content in the users UI language if present */ wsprintfW(lpszPath + dwLen, szWebMui, lidUser); - strcpyW(lpszPath + dwLen + szWebMuiLen, lpszFile); + strcpyW(lpszPath + dwLen + ARRAY_SIZE(szWebMui), lpszFile); if (PathFileExistsW(lpszPath)) return S_OK; } diff --git a/dlls/shlwapi/reg.c b/dlls/shlwapi/reg.c index a72f4c24e4..375c25429d 100644 --- a/dlls/shlwapi/reg.c +++ b/dlls/shlwapi/reg.c @@ -2426,19 +2426,18 @@ HRESULT WINAPI SHRegGetCLSIDKeyW(REFGUID guid, LPCWSTR lpszValue, BOOL bUseHKCU, 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\', 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\', 'E','x','p','l','o','r','e','r','\\','C','L','S','I','D','\\' }; -#define szClassIdKeyLen (sizeof(szClassIdKey)/sizeof(WCHAR)) WCHAR szKey[MAX_PATH]; DWORD dwRet; HKEY hkey; /* Create the key string */ memcpy(szKey, szClassIdKey, sizeof(szClassIdKey)); - SHStringFromGUIDW(guid, szKey + szClassIdKeyLen, 39); /* Append guid */ + SHStringFromGUIDW(guid, szKey + ARRAY_SIZE(szClassIdKey), 39); /* Append guid */ if(lpszValue) { - szKey[szClassIdKeyLen + 39] = '\\'; - strcpyW(szKey + szClassIdKeyLen + 40, lpszValue); /* Append value name */ + szKey[ARRAY_SIZE(szClassIdKey) + 39] = '\\'; + strcpyW(szKey + ARRAY_SIZE(szClassIdKey) + 40, lpszValue); /* Append value name */ } hkey = bUseHKCU ? HKEY_CURRENT_USER : HKEY_CLASSES_ROOT; diff --git a/dlls/shlwapi/url.c b/dlls/shlwapi/url.c index c7d717b2d7..92b4a216cb 100644 --- a/dlls/shlwapi/url.c +++ b/dlls/shlwapi/url.c @@ -2570,7 +2570,7 @@ HRESULT WINAPI MLBuildResURLW(LPCWSTR lpszLibName, HMODULE hMod, DWORD dwFlags, LPCWSTR lpszRes, LPWSTR lpszDest, DWORD dwDestLen) { static const WCHAR szRes[] = { 'r','e','s',':','/','/','\0' }; -#define szResLen ((sizeof(szRes) - sizeof(WCHAR))/sizeof(WCHAR)) + static const unsigned int szResLen = ARRAY_SIZE(szRes) - 1; HRESULT hRet = E_FAIL; TRACE("(%s,%p,0x%08x,%s,%p,%d)\n", debugstr_w(lpszLibName), hMod, dwFlags, -- 2.14.4

3 2

[PATCH] wininet: Use the ARRAY_SIZE() macro
by Michael Stefaniuc 20 Sep '18

20 Sep '18

Signed-off-by: Michael Stefaniuc <mstefani(a)winehq.org> --- dlls/wininet/cookie.c | 24 ++++++++++++------------ dlls/wininet/dialogs.c | 24 +++++++++++------------- dlls/wininet/http.c | 31 ++++++++++++++----------------- dlls/wininet/internet.c | 10 +++++----- dlls/wininet/netconnection.c | 8 ++++---- dlls/wininet/urlcache.c | 8 ++++---- dlls/wininet/utility.c | 2 +- 7 files changed, 51 insertions(+), 56 deletions(-) diff --git a/dlls/wininet/cookie.c b/dlls/wininet/cookie.c index 60b8335639..a1ea1deb1b 100644 --- a/dlls/wininet/cookie.c +++ b/dlls/wininet/cookie.c @@ -151,18 +151,18 @@ static WCHAR *create_cookie_url(substr_t domain, substr_t path, substr_t *ret_pa static const WCHAR cookie_prefix[] = {'C','o','o','k','i','e',':'}; - user_len = sizeof(user)/sizeof(WCHAR); + user_len = ARRAY_SIZE(user); if(!GetUserNameW(user, &user_len)) return FALSE; user_len--; - len = sizeof(cookie_prefix)/sizeof(WCHAR) + user_len + 1 /* @ */ + domain.len + path.len; + len = ARRAY_SIZE(cookie_prefix) + user_len + 1 /* @ */ + domain.len + path.len; url = heap_alloc((len+1) * sizeof(WCHAR)); if(!url) return NULL; memcpy(url, cookie_prefix, sizeof(cookie_prefix)); - p = url + sizeof(cookie_prefix)/sizeof(WCHAR); + p = url + ARRAY_SIZE(cookie_prefix); memcpy(p, user, user_len*sizeof(WCHAR)); p += user_len; @@ -658,7 +658,7 @@ DWORD get_cookie_header(const WCHAR *host, const WCHAR *path, WCHAR **ret) ptr = header = heap_alloc(sizeof(cookieW) + (cookie_set.string_len + 3 /* crlf0 */) * sizeof(WCHAR)); if(header) { memcpy(ptr, cookieW, sizeof(cookieW)); - ptr += sizeof(cookieW)/sizeof(*cookieW); + ptr += ARRAY_SIZE(cookieW); cookie_set_to_string(&cookie_set, ptr); heap_free(cookie_set.cookies); @@ -949,7 +949,7 @@ DWORD set_cookie(substr_t domain, substr_t path, substr_t name, substr_t data, D if(!(end_ptr = memchrW(data.str, ';', data.len))) end_ptr = data.str + data.len; - if(data.len >= (len = sizeof(szDomain)/sizeof(WCHAR)) && !strncmpiW(data.str, szDomain, len)) { + if(data.len >= (len = ARRAY_SIZE(szDomain)) && !strncmpiW(data.str, szDomain, len)) { substr_skip(&data, len); if(data.len && *data.str == '.') @@ -960,17 +960,17 @@ DWORD set_cookie(substr_t domain, substr_t path, substr_t name, substr_t data, D domain = substr(data.str, end_ptr-data.str); TRACE("Parsing new domain %s\n", debugstr_wn(domain.str, domain.len)); - }else if(data.len >= (len = sizeof(szPath)/sizeof(WCHAR)) && !strncmpiW(data.str, szPath, len)) { + }else if(data.len >= (len = ARRAY_SIZE(szPath)) && !strncmpiW(data.str, szPath, len)) { substr_skip(&data, len); path = substr(data.str, end_ptr - data.str); TRACE("Parsing new path %s\n", debugstr_wn(path.str, path.len)); - }else if(data.len >= (len = sizeof(szExpires)/sizeof(WCHAR)) && !strncmpiW(data.str, szExpires, len)) { + }else if(data.len >= (len = ARRAY_SIZE(szExpires)) && !strncmpiW(data.str, szExpires, len)) { SYSTEMTIME st; WCHAR buf[128]; substr_skip(&data, len); - if(end_ptr - data.str < sizeof(buf)/sizeof(WCHAR)-1) { + if(end_ptr - data.str < ARRAY_SIZE(buf)-1) { memcpy(buf, data.str, data.len*sizeof(WCHAR)); buf[data.len] = 0; @@ -983,10 +983,10 @@ DWORD set_cookie(substr_t domain, substr_t path, substr_t name, substr_t data, D } } } - }else if(data.len >= (len = sizeof(szSecure)/sizeof(WCHAR)) && !strncmpiW(data.str, szSecure, len)) { + }else if(data.len >= (len = ARRAY_SIZE(szSecure)) && !strncmpiW(data.str, szSecure, len)) { substr_skip(&data, len); FIXME("secure not handled\n"); - }else if(data.len >= (len = sizeof(szHttpOnly)/sizeof(WCHAR)) && !strncmpiW(data.str, szHttpOnly, len)) { + }else if(data.len >= (len = ARRAY_SIZE(szHttpOnly)) && !strncmpiW(data.str, szHttpOnly, len)) { substr_skip(&data, len); if(!(flags & INTERNET_COOKIE_HTTPONLY)) { @@ -996,11 +996,11 @@ DWORD set_cookie(substr_t domain, substr_t path, substr_t name, substr_t data, D } cookie_flags |= INTERNET_COOKIE_HTTPONLY; - }else if(data.len >= (len = sizeof(szVersion)/sizeof(WCHAR)) && !strncmpiW(data.str, szVersion, len)) { + }else if(data.len >= (len = ARRAY_SIZE(szVersion)) && !strncmpiW(data.str, szVersion, len)) { substr_skip(&data, len); FIXME("version not handled (%s)\n",debugstr_wn(data.str, data.len)); - }else if(data.len >= (len = sizeof(max_ageW)/sizeof(WCHAR)) && !strncmpiW(data.str, max_ageW, len)) { + }else if(data.len >= (len = ARRAY_SIZE(max_ageW)) && !strncmpiW(data.str, max_ageW, len)) { /* Native doesn't support Max-Age attribute. */ WARN("Max-Age ignored\n"); }else if(data.len) { diff --git a/dlls/wininet/dialogs.c b/dlls/wininet/dialogs.c index b13b566a8e..b4aa49c0eb 100644 --- a/dlls/wininet/dialogs.c +++ b/dlls/wininet/dialogs.c @@ -135,12 +135,10 @@ static BOOL WININET_GetSetPassword( HWND hdlg, LPCWSTR szServer, if( bSet ) { szUserPass[0] = 0; - GetWindowTextW( hUserItem, szUserPass, - (sizeof szUserPass-1)/sizeof(WCHAR) ); + GetWindowTextW( hUserItem, szUserPass, ARRAY_SIZE( szUserPass ) - 1 ); lstrcatW(szUserPass, szColon); u_len = strlenW( szUserPass ); - GetWindowTextW( hPassItem, szUserPass+u_len, - (sizeof szUserPass)/sizeof(WCHAR)-u_len ); + GetWindowTextW( hPassItem, szUserPass+u_len, ARRAY_SIZE( szUserPass ) - u_len ); r_len = (strlenW( szResource ) + 1)*sizeof(WCHAR); u_len = (strlenW( szUserPass ) + 1)*sizeof(WCHAR); @@ -230,7 +228,7 @@ static INT_PTR WINAPI WININET_ProxyPasswordDialog( /* extract the Realm from the proxy response and show it */ if( WININET_GetAuthRealm( params->req->hdr.hInternet, - szRealm, sizeof szRealm/sizeof(WCHAR), TRUE ) ) + szRealm, ARRAY_SIZE( szRealm ), TRUE ) ) { hitem = GetDlgItem( hdlg, IDC_REALM ); SetWindowTextW( hitem, szRealm ); @@ -257,18 +255,18 @@ static INT_PTR WINAPI WININET_ProxyPasswordDialog( username[0] = 0; hitem = GetDlgItem( hdlg, IDC_USERNAME ); if( hitem ) - GetWindowTextW( hitem, username, sizeof username/sizeof(WCHAR) ); - + GetWindowTextW( hitem, username, ARRAY_SIZE( username )); + password[0] = 0; hitem = GetDlgItem( hdlg, IDC_PASSWORD ); if( hitem ) - GetWindowTextW( hitem, password, sizeof password/sizeof(WCHAR) ); + GetWindowTextW( hitem, password, ARRAY_SIZE( password )); hitem = GetDlgItem( hdlg, IDC_SAVEPASSWORD ); if( hitem && SendMessageW( hitem, BM_GETSTATE, 0, 0 ) && WININET_GetAuthRealm( params->req->hdr.hInternet, - szRealm, sizeof szRealm/sizeof(WCHAR), TRUE) ) + szRealm, ARRAY_SIZE( szRealm ), TRUE) ) WININET_GetSetPassword( hdlg, params->req->session->appInfo->proxy, szRealm, TRUE ); WININET_SetAuthorization( params->req, username, password, TRUE ); @@ -305,7 +303,7 @@ static INT_PTR WINAPI WININET_PasswordDialog( /* extract the Realm from the response and show it */ if( WININET_GetAuthRealm( params->req->hdr.hInternet, - szRealm, sizeof szRealm/sizeof(WCHAR), FALSE ) ) + szRealm, ARRAY_SIZE( szRealm ), FALSE ) ) { hitem = GetDlgItem( hdlg, IDC_REALM ); SetWindowTextW( hitem, szRealm ); @@ -332,18 +330,18 @@ static INT_PTR WINAPI WININET_PasswordDialog( username[0] = 0; hitem = GetDlgItem( hdlg, IDC_USERNAME ); if( hitem ) - GetWindowTextW( hitem, username, sizeof username/sizeof(WCHAR) ); + GetWindowTextW( hitem, username, ARRAY_SIZE( username )); password[0] = 0; hitem = GetDlgItem( hdlg, IDC_PASSWORD ); if( hitem ) - GetWindowTextW( hitem, password, sizeof password/sizeof(WCHAR) ); + GetWindowTextW( hitem, password, ARRAY_SIZE( password )); hitem = GetDlgItem( hdlg, IDC_SAVEPASSWORD ); if( hitem && SendMessageW( hitem, BM_GETSTATE, 0, 0 ) && WININET_GetAuthRealm( params->req->hdr.hInternet, - szRealm, sizeof szRealm/sizeof(WCHAR), FALSE )) + szRealm, ARRAY_SIZE( szRealm ), FALSE )) { WININET_GetSetPassword( hdlg, params->req->session->hostName, szRealm, TRUE ); } diff --git a/dlls/wininet/http.c b/dlls/wininet/http.c index 9e839ce16f..4122067e41 100644 --- a/dlls/wininet/http.c +++ b/dlls/wininet/http.c @@ -1712,7 +1712,7 @@ static BOOL HTTP_DomainMatches(LPCWSTR server, substr_t domain) const WCHAR *dot, *ptr; int len; - if(domain.len == sizeof(localW)/sizeof(WCHAR)-1 && !strncmpiW(domain.str, localW, domain.len) && !strchrW(server, '.' )) + if(domain.len == ARRAY_SIZE(localW)-1 && !strncmpiW(domain.str, localW, domain.len) && !strchrW(server, '.' )) return TRUE; if(domain.len && *domain.str != '*') @@ -2409,8 +2409,8 @@ static void create_cache_entry(http_request_t *req) if(!end) end = ptr + strlenW(ptr); - if(!strncmpiW(ptr, no_cacheW, sizeof(no_cacheW)/sizeof(*no_cacheW)-1) - || !strncmpiW(ptr, no_storeW, sizeof(no_storeW)/sizeof(*no_storeW)-1)) { + if(!strncmpiW(ptr, no_cacheW, ARRAY_SIZE(no_cacheW)-1) + || !strncmpiW(ptr, no_storeW, ARRAY_SIZE(no_storeW)-1)) { b = FALSE; break; } @@ -3871,18 +3871,18 @@ BOOL WINAPI HttpQueryInfoW(HINTERNET hHttpRequest, DWORD dwInfoLevel, TRACE("(%p, 0x%08x)--> %d\n", hHttpRequest, dwInfoLevel, info); TRACE(" Attribute:"); - for (i = 0; i < (sizeof(query_flags) / sizeof(query_flags[0])); i++) { + for (i = 0; i < ARRAY_SIZE(query_flags); i++) { if (query_flags[i].val == info) { TRACE(" %s", query_flags[i].name); break; } } - if (i == (sizeof(query_flags) / sizeof(query_flags[0]))) { + if (i == ARRAY_SIZE(query_flags)) { TRACE(" Unknown (%08x)", info); } TRACE(" Modifier:"); - for (i = 0; i < (sizeof(modifier_flags) / sizeof(modifier_flags[0])); i++) { + for (i = 0; i < ARRAY_SIZE(modifier_flags); i++) { if (modifier_flags[i].val & info_mod) { TRACE(" %s", modifier_flags[i].name); info_mod &= ~ modifier_flags[i].val; @@ -4208,7 +4208,7 @@ static WORD HTTP_ParseWkday(LPCWSTR day) { 'f','r','i',0 }, { 's','a','t',0 }}; unsigned int i; - for (i = 0; i < sizeof(days)/sizeof(*days); i++) + for (i = 0; i < ARRAY_SIZE(days); i++) if (!strcmpiW(day, days[i])) return i; @@ -4313,7 +4313,7 @@ static BOOL HTTP_ParseDateAsAsctime(LPCWSTR value, FILETIME *ft) unsigned long num; for (ptr = value, dayPtr = day; *ptr && !isspaceW(*ptr) && - dayPtr - day < sizeof(day) / sizeof(day[0]) - 1; ptr++, dayPtr++) + dayPtr - day < ARRAY_SIZE(day) - 1; ptr++, dayPtr++) *dayPtr = *ptr; *dayPtr = 0; st.wDayOfWeek = HTTP_ParseWkday(day); @@ -4326,8 +4326,7 @@ static BOOL HTTP_ParseDateAsAsctime(LPCWSTR value, FILETIME *ft) while (isspaceW(*ptr)) ptr++; - for (monthPtr = month; !isspaceW(*ptr) && - monthPtr - month < sizeof(month) / sizeof(month[0]) - 1; + for (monthPtr = month; !isspaceW(*ptr) && monthPtr - month < ARRAY_SIZE(month) - 1; monthPtr++, ptr++) *monthPtr = *ptr; *monthPtr = 0; @@ -4423,8 +4422,7 @@ static BOOL HTTP_ParseRfc1123Date(LPCWSTR value, FILETIME *ft) while (isspaceW(*ptr)) ptr++; - for (monthPtr = month; !isspaceW(*ptr) && - monthPtr - month < sizeof(month) / sizeof(month[0]) - 1; + for (monthPtr = month; !isspaceW(*ptr) && monthPtr - month < ARRAY_SIZE(month) - 1; monthPtr++, ptr++) *monthPtr = *ptr; *monthPtr = 0; @@ -4471,7 +4469,7 @@ static WORD HTTP_ParseWeekday(LPCWSTR day) { 'f','r','i','d','a','y',0 }, { 's','a','t','u','r','d','a','y',0 }}; unsigned int i; - for (i = 0; i < sizeof(days)/sizeof(*days); i++) + for (i = 0; i < ARRAY_SIZE(days); i++) if (!strcmpiW(day, days[i])) return i; @@ -4501,7 +4499,7 @@ static BOOL HTTP_ParseRfc850Date(LPCWSTR value, FILETIME *ft) return FALSE; } } - else if (ptr - value < sizeof(day) / sizeof(day[0])) + else if (ptr - value < ARRAY_SIZE(day)) { memcpy(day, value, (ptr - value) * sizeof(WCHAR)); day[ptr - value + 1] = 0; @@ -4538,8 +4536,7 @@ static BOOL HTTP_ParseRfc850Date(LPCWSTR value, FILETIME *ft) } ptr++; - for (monthPtr = month; *ptr != '-' && - monthPtr - month < sizeof(month) / sizeof(month[0]) - 1; + for (monthPtr = month; *ptr != '-' && monthPtr - month < ARRAY_SIZE(month) - 1; monthPtr++, ptr++) *monthPtr = *ptr; *monthPtr = 0; @@ -4827,7 +4824,7 @@ static void set_content_length_header( http_request_t *request, DWORD len, DWORD { static const WCHAR fmtW[] = {'C','o','n','t','e','n','t','-','L','e','n','g','t','h',':',' ','%','u','\r','\n',0}; - WCHAR buf[sizeof(fmtW)/sizeof(fmtW[0]) + 10]; + WCHAR buf[ARRAY_SIZE(fmtW) + 10]; sprintfW( buf, fmtW, len ); HTTP_HttpAddRequestHeadersW( request, buf, ~0u, flags ); diff --git a/dlls/wininet/internet.c b/dlls/wininet/internet.c index b407e851af..6db42d692d 100644 --- a/dlls/wininet/internet.c +++ b/dlls/wininet/internet.c @@ -777,7 +777,7 @@ static void dump_INTERNET_FLAGS(DWORD dwFlags) #undef FE unsigned int i; - for (i = 0; i < (sizeof(flag) / sizeof(flag[0])); i++) { + for (i = 0; i < ARRAY_SIZE(flag); i++) { if (flag[i].val & dwFlags) { TRACE(" %s", flag[i].name); dwFlags &= ~flag[i].val; @@ -1018,7 +1018,7 @@ HINTERNET WINAPI InternetOpenW(LPCWSTR lpszAgent, DWORD dwAccessType, TRACE("(%s, %i, %s, %s, %i)\n", debugstr_w(lpszAgent), dwAccessType, debugstr_w(lpszProxy), debugstr_w(lpszProxyBypass), dwFlags); - for (i = 0; i < (sizeof(access_type) / sizeof(access_type[0])); i++) { + for (i = 0; i < ARRAY_SIZE(access_type); i++) { if (access_type[i].val == dwAccessType) { access_type_str = access_type[i].name; break; @@ -1623,7 +1623,7 @@ static INTERNET_SCHEME GetInternetSchemeW(LPCWSTR lpszScheme, DWORD nMaxCmp) if(lpszScheme==NULL) return INTERNET_SCHEME_UNKNOWN; - for (i = 0; i < sizeof(url_schemes)/sizeof(url_schemes[0]); i++) + for (i = 0; i < ARRAY_SIZE(url_schemes); i++) if (!strncmpiW(lpszScheme, url_schemes[i], nMaxCmp)) return INTERNET_SCHEME_FIRST + i; @@ -4066,7 +4066,7 @@ static LPCWSTR INTERNET_GetSchemeString(INTERNET_SCHEME scheme) if (scheme < INTERNET_SCHEME_FIRST) return NULL; index = scheme - INTERNET_SCHEME_FIRST; - if (index >= sizeof(url_schemes)/sizeof(url_schemes[0])) + if (index >= ARRAY_SIZE(url_schemes)) return NULL; return (LPCWSTR)url_schemes[index]; } @@ -4343,7 +4343,7 @@ BOOL WINAPI InternetCreateUrlW(LPURL_COMPONENTSW lpUrlComponents, DWORD dwFlags, if (!scheme_is_opaque(nScheme) || lpUrlComponents->lpszHostName) { memcpy(lpszUrl, slashSlashW, sizeof(slashSlashW)); - lpszUrl += sizeof(slashSlashW)/sizeof(slashSlashW[0]); + lpszUrl += ARRAY_SIZE(slashSlashW); } if (lpUrlComponents->lpszUserName) diff --git a/dlls/wininet/netconnection.c b/dlls/wininet/netconnection.c index ccdb8818d7..4ad22177ee 100644 --- a/dlls/wininet/netconnection.c +++ b/dlls/wininet/netconnection.c @@ -639,7 +639,7 @@ static BOOL send_ssl_chunk(netconn_t *conn, const void *msg, size_t size) {conn->ssl_sizes.cbTrailer, SECBUFFER_STREAM_TRAILER, conn->ssl_buf+conn->ssl_sizes.cbHeader+size}, {0, SECBUFFER_EMPTY, NULL} }; - SecBufferDesc buf_desc = {SECBUFFER_VERSION, sizeof(bufs)/sizeof(*bufs), bufs}; + SecBufferDesc buf_desc = {SECBUFFER_VERSION, ARRAY_SIZE(bufs), bufs}; SECURITY_STATUS res; memcpy(bufs[1].pvBuffer, msg, size); @@ -698,7 +698,7 @@ static BOOL read_ssl_chunk(netconn_t *conn, void *buf, SIZE_T buf_size, BOOL blo { const SIZE_T ssl_buf_size = conn->ssl_sizes.cbHeader+conn->ssl_sizes.cbMaximumMessage+conn->ssl_sizes.cbTrailer; SecBuffer bufs[4]; - SecBufferDesc buf_desc = {SECBUFFER_VERSION, sizeof(bufs)/sizeof(*bufs), bufs}; + SecBufferDesc buf_desc = {SECBUFFER_VERSION, ARRAY_SIZE(bufs), bufs}; SSIZE_T size, buf_len = 0; int i; SECURITY_STATUS res; @@ -781,7 +781,7 @@ static BOOL read_ssl_chunk(netconn_t *conn, void *buf, SIZE_T buf_size, BOOL blo } } while(res != SEC_E_OK); - for(i=0; i < sizeof(bufs)/sizeof(*bufs); i++) { + for(i = 0; i < ARRAY_SIZE(bufs); i++) { if(bufs[i].BufferType == SECBUFFER_DATA) { size = min(buf_size, bufs[i].cbBuffer); memcpy(buf, bufs[i].pvBuffer, size); @@ -798,7 +798,7 @@ static BOOL read_ssl_chunk(netconn_t *conn, void *buf, SIZE_T buf_size, BOOL blo } } - for(i=0; i < sizeof(bufs)/sizeof(*bufs); i++) { + for(i = 0; i < ARRAY_SIZE(bufs); i++) { if(bufs[i].BufferType == SECBUFFER_EXTRA) { conn->extra_buf = heap_alloc(bufs[i].cbBuffer); if(!conn->extra_buf) diff --git a/dlls/wininet/urlcache.c b/dlls/wininet/urlcache.c index c7b5f9ecad..55cffb7911 100644 --- a/dlls/wininet/urlcache.c +++ b/dlls/wininet/urlcache.c @@ -766,7 +766,7 @@ static void cache_containers_init(void) }; DWORD i; - for (i = 0; i < sizeof(DefaultContainerData) / sizeof(DefaultContainerData[0]); i++) + for (i = 0; i < ARRAY_SIZE(DefaultContainerData); i++) { WCHAR wszCachePath[MAX_PATH]; WCHAR wszMutexName[MAX_PATH]; @@ -1478,12 +1478,12 @@ static DWORD urlcache_hash_key(LPCSTR lpszKey) BYTE key[4]; DWORD i; - for (i = 0; i < sizeof(key) / sizeof(key[0]); i++) + for (i = 0; i < ARRAY_SIZE(key); i++) key[i] = lookupTable[(*lpszKey + i) & 0xFF]; for (lpszKey++; *lpszKey; lpszKey++) { - for (i = 0; i < sizeof(key) / sizeof(key[0]); i++) + for (i = 0; i < ARRAY_SIZE(key); i++) key[i] = lookupTable[*lpszKey ^ key[i]]; } @@ -2441,7 +2441,7 @@ BOOL WINAPI FreeUrlCacheSpaceW(LPCWSTR cache_path, DWORD size, DWORD filter) hash_table_entry = 0; rate_no = 0; GetSystemTimeAsFileTime(&cur_time); - while(rate_no<sizeof(rate)/sizeof(*rate) && + while(rate_no < ARRAY_SIZE(rate) && urlcache_next_entry(header, &hash_table_off, &hash_table_entry, &hash_entry, &entry)) { if(entry->signature != URL_SIGNATURE) { WARN("only url entries are currently supported\n"); diff --git a/dlls/wininet/utility.c b/dlls/wininet/utility.c index 1492c039ef..90058dc28b 100644 --- a/dlls/wininet/utility.c +++ b/dlls/wininet/utility.c @@ -214,7 +214,7 @@ static const char *get_callback_name(DWORD dwInternetStatus) { }; DWORD i; - for (i = 0; i < (sizeof(internet_status) / sizeof(internet_status[0])); i++) { + for (i = 0; i < ARRAY_SIZE(internet_status); i++) { if (internet_status[i].val == dwInternetStatus) return internet_status[i].name; } return "Unknown"; -- 2.14.4

1 0

[PATCH] wininet: Avoid an ARRAY_SIZE-like macro
by Michael Stefaniuc 20 Sep '18

20 Sep '18

Signed-off-by: Michael Stefaniuc <mstefani(a)winehq.org> --- dlls/wininet/http.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/dlls/wininet/http.c b/dlls/wininet/http.c index b7be9939a1..9e839ce16f 100644 --- a/dlls/wininet/http.c +++ b/dlls/wininet/http.c @@ -3513,8 +3513,6 @@ static const LPCWSTR header_lookup[] = { szUnless_Modified_Since, /* HTTP_QUERY_UNLESS_MODIFIED_SINCE = 70 */ }; -#define LAST_TABLE_HEADER (sizeof(header_lookup)/sizeof(header_lookup[0])) - /*********************************************************************** * HTTP_HttpQueryInfoW (internal) */ @@ -3700,9 +3698,9 @@ static DWORD HTTP_HttpQueryInfoW(http_request_t *request, DWORD dwInfoLevel, return res; } default: - assert (LAST_TABLE_HEADER == (HTTP_QUERY_UNLESS_MODIFIED_SINCE + 1)); + assert (ARRAY_SIZE(header_lookup) == (HTTP_QUERY_UNLESS_MODIFIED_SINCE + 1)); - if (level < LAST_TABLE_HEADER && header_lookup[level]) + if (level < ARRAY_SIZE(header_lookup) && header_lookup[level]) index = HTTP_GetCustomHeaderIndex(request, header_lookup[level], requested_index,request_only); } -- 2.14.4

1 0

[PATCH v2 1/8] comctl32/listbox: Make SetCount fail if LBS_NODATA is not set
by Gabriel Ivăncescu 20 Sep '18

20 Sep '18

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- Supersedes series starting with 151474. v2: Looks like Windows accepts both LBS_OWNERDRAWFIXED and LBS_OWNERDRAWVARIABLE at once, for some stupid reason, and only LBS_OWNERDRAWFIXED takes effect (based on testing on Windows XP). So keep LBS_NODATA if they're both set. dlls/comctl32/listbox.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/dlls/comctl32/listbox.c b/dlls/comctl32/listbox.c index 2137ef8..0a7c341 100644 --- a/dlls/comctl32/listbox.c +++ b/dlls/comctl32/listbox.c @@ -1752,7 +1752,7 @@ static LRESULT LISTBOX_SetCount( LB_DESCR *descr, INT count ) { LRESULT ret; - if (HAS_STRINGS(descr)) + if (!(descr->style & LBS_NODATA)) { SetLastError(ERROR_SETCOUNT_ON_BAD_LB); return LB_ERR; @@ -2518,6 +2518,9 @@ static BOOL LISTBOX_Create( HWND hwnd, LPHEADCOMBO lphc ) if (descr->style & LBS_OWNERDRAWVARIABLE) descr->style |= LBS_NOINTEGRALHEIGHT; descr->item_height = LISTBOX_SetFont( descr, 0 ); + if ((descr->style & (LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_SORT)) != LBS_OWNERDRAWFIXED) + descr->style &= ~LBS_NODATA; + if (descr->style & LBS_OWNERDRAWFIXED) { if( descr->lphc && (descr->lphc->dwStyle & CBS_DROPDOWN)) -- 1.9.1

2 11

[PATCH 1/5] quartz/tests: Add some tests for IFilterGraph_ConnectDirect() and IFilterGraph_Disconnect().
by Zebediah Figura 20 Sep '18

20 Sep '18

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/quartz/tests/filtergraph.c | 184 ++++++++++++++++++++++++++++++++++++---- 1 file changed, 168 insertions(+), 16 deletions(-) diff --git a/dlls/quartz/tests/filtergraph.c b/dlls/quartz/tests/filtergraph.c index 5035f80..b1059ca 100644 --- a/dlls/quartz/tests/filtergraph.c +++ b/dlls/quartz/tests/filtergraph.c @@ -767,6 +767,7 @@ struct testpin PIN_DIRECTION dir; IBaseFilter *filter; IPin *peer; + AM_MEDIA_TYPE *mt; IEnumMediaTypes IEnumMediaTypes_iface; const AM_MEDIA_TYPE *types; @@ -991,7 +992,19 @@ static HRESULT WINAPI testpin_EndOfStream(IPin *iface) return E_NOTIMPL; } -static HRESULT WINAPI testsink_Connect(IPin *iface, IPin *peer, const AM_MEDIA_TYPE *mt) +static HRESULT WINAPI no_Connect(IPin *iface, IPin *peer, const AM_MEDIA_TYPE *mt) +{ + ok(0, "Unexpected call.\n"); + return E_NOTIMPL; +} + +static HRESULT WINAPI no_ReceiveConnection(IPin *iface, IPin *peer, const AM_MEDIA_TYPE *mt) +{ + ok(0, "Unexpected call.\n"); + return E_NOTIMPL; +} + +static HRESULT WINAPI no_EnumMediaTypes(IPin *iface, IEnumMediaTypes **out) { ok(0, "Unexpected call.\n"); return E_NOTIMPL; @@ -1007,18 +1020,12 @@ static HRESULT WINAPI testsink_ReceiveConnection(IPin *iface, IPin *peer, const return S_OK; } -static HRESULT WINAPI testsink_EnumMediaTypes(IPin *iface, IEnumMediaTypes **out) -{ - ok(0, "Unexpected call.\n"); - return E_NOTIMPL; -} - static const IPinVtbl testsink_vtbl = { testpin_QueryInterface, testpin_AddRef, testpin_Release, - testsink_Connect, + no_Connect, testsink_ReceiveConnection, testpin_Disconnect, testpin_ConnectedTo, @@ -1027,7 +1034,7 @@ static const IPinVtbl testsink_vtbl = testpin_QueryDirection, testpin_QueryId, testpin_QueryAccept, - testsink_EnumMediaTypes, + no_EnumMediaTypes, testpin_QueryInternalConnections, testpin_EndOfStream, testpin_BeginFlush, @@ -1057,19 +1064,13 @@ static HRESULT WINAPI testsource_Connect(IPin *iface, IPin *peer, const AM_MEDIA return IPin_ReceiveConnection(peer, &pin->IPin_iface, mt); } -static HRESULT WINAPI testsource_ReceiveConnection(IPin *iface, IPin *peer, const AM_MEDIA_TYPE *mt) -{ - ok(0, "Unexpected call.\n"); - return E_NOTIMPL; -} - static const IPinVtbl testsource_vtbl = { testpin_QueryInterface, testpin_AddRef, testpin_Release, testsource_Connect, - testsource_ReceiveConnection, + no_ReceiveConnection, testpin_Disconnect, testpin_ConnectedTo, testpin_ConnectionMediaType, @@ -1864,6 +1865,156 @@ static void test_add_remove_filter(void) ok(filter.ref == 1, "Got outstanding refcount %d.\n", filter.ref); } +static HRESULT WINAPI test_connect_direct_Connect(IPin *iface, IPin *peer, const AM_MEDIA_TYPE *mt) +{ + struct testpin *pin = impl_from_IPin(iface); + if (winetest_debug > 1) trace("%p->Connect()\n", pin); + + pin->peer = peer; + IPin_AddRef(peer); + pin->mt = (AM_MEDIA_TYPE *)mt; + return S_OK; +} + +static const IPinVtbl test_connect_direct_vtbl = +{ + testpin_QueryInterface, + testpin_AddRef, + testpin_Release, + test_connect_direct_Connect, + no_ReceiveConnection, + testpin_Disconnect, + testpin_ConnectedTo, + testpin_ConnectionMediaType, + testpin_QueryPinInfo, + testpin_QueryDirection, + testpin_QueryId, + testpin_QueryAccept, + no_EnumMediaTypes, + testpin_QueryInternalConnections, + testpin_EndOfStream, + testpin_BeginFlush, + testpin_EndFlush, + testpin_NewSegment +}; + +static void test_connect_direct_init(struct testpin *pin, PIN_DIRECTION dir) +{ + memset(pin, 0, sizeof(*pin)); + pin->IPin_iface.lpVtbl = &test_connect_direct_vtbl; + pin->ref = 1; + pin->dir = dir; +} + +static void test_connect_direct(void) +{ + struct testpin source_pin, sink_pin; + struct testfilter source, sink; + + IFilterGraph2 *graph = create_graph(); + AM_MEDIA_TYPE mt; + HRESULT hr; + + test_connect_direct_init(&source_pin, PINDIR_OUTPUT); + test_connect_direct_init(&sink_pin, PINDIR_INPUT); + testfilter_init(&source, &source_pin, 1); + testfilter_init(&sink, &sink_pin, 1); + + hr = IFilterGraph2_AddFilter(graph, &source.IBaseFilter_iface, NULL); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IFilterGraph2_AddFilter(graph, &sink.IBaseFilter_iface, NULL); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IFilterGraph2_ConnectDirect(graph, &source_pin.IPin_iface, &sink_pin.IPin_iface, NULL); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(source_pin.peer == &sink_pin.IPin_iface, "Got peer %p.\n", source_pin.peer); + ok(!source_pin.mt, "Got mt %p.\n", source_pin.mt); + ok(!sink_pin.peer, "Got peer %p.\n", sink_pin.peer); + + hr = IFilterGraph2_Disconnect(graph, &sink_pin.IPin_iface); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + ok(source_pin.peer == &sink_pin.IPin_iface, "Got peer %p.\n", source_pin.peer); + ok(!sink_pin.peer, "Got peer %p.\n", sink_pin.peer); + + hr = IFilterGraph2_Disconnect(graph, &source_pin.IPin_iface); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(!source_pin.peer, "Got peer %p.\n", source_pin.peer); + ok(!sink_pin.peer, "Got peer %p.\n", sink_pin.peer); + + /* Swap the pins when connecting. */ + hr = IFilterGraph2_ConnectDirect(graph, &sink_pin.IPin_iface, &source_pin.IPin_iface, NULL); + ok(hr == S_OK, "Got hr %#x.\n", hr); +todo_wine + ok(sink_pin.peer == &source_pin.IPin_iface, "Got peer %p.\n", sink_pin.peer); + ok(!sink_pin.mt, "Got mt %p.\n", sink_pin.mt); +todo_wine + ok(!source_pin.peer, "Got peer %p.\n", source_pin.peer); + + hr = IFilterGraph2_Disconnect(graph, &sink_pin.IPin_iface); +todo_wine + ok(hr == S_OK, "Got hr %#x.\n", hr); +todo_wine + ok(!source_pin.peer, "Got peer %p.\n", source_pin.peer); + ok(!sink_pin.peer, "Got peer %p.\n", sink_pin.peer); + + /* Disconnect() does not disconnect the peer. */ + hr = IFilterGraph2_ConnectDirect(graph, &source_pin.IPin_iface, &sink_pin.IPin_iface, NULL); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(source_pin.peer == &sink_pin.IPin_iface, "Got peer %p.\n", source_pin.peer); + ok(!source_pin.mt, "Got mt %p.\n", source_pin.mt); + ok(!sink_pin.peer, "Got peer %p.\n", sink_pin.peer); + + sink_pin.peer = &source_pin.IPin_iface; + IPin_AddRef(sink_pin.peer); + + hr = IFilterGraph2_Disconnect(graph, &sink_pin.IPin_iface); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(source_pin.peer == &sink_pin.IPin_iface, "Got peer %p.\n", source_pin.peer); + ok(!sink_pin.peer, "Got peer %p.\n", sink_pin.peer); + + hr = IFilterGraph2_Disconnect(graph, &source_pin.IPin_iface); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(!source_pin.peer, "Got peer %p.\n", source_pin.peer); + ok(!sink_pin.peer, "Got peer %p.\n", sink_pin.peer); + + /* Test specifying the media type. */ + hr = IFilterGraph2_ConnectDirect(graph, &source_pin.IPin_iface, &sink_pin.IPin_iface, &mt); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(source_pin.peer == &sink_pin.IPin_iface, "Got peer %p.\n", source_pin.peer); + ok(source_pin.mt == &mt, "Got mt %p.\n", source_pin.mt); + ok(!sink_pin.peer, "Got peer %p.\n", sink_pin.peer); + + /* Both pins are disconnected when a filter is removed. */ + sink_pin.peer = &source_pin.IPin_iface; + IPin_AddRef(sink_pin.peer); + hr = IFilterGraph2_RemoveFilter(graph, &source.IBaseFilter_iface); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(!source_pin.peer, "Got peer %p.\n", source_pin.peer); + ok(!sink_pin.peer, "Got peer %p.\n", sink_pin.peer); + + /* Or when the graph is destroyed. */ + hr = IFilterGraph2_AddFilter(graph, &source.IBaseFilter_iface, NULL); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IFilterGraph2_ConnectDirect(graph, &source_pin.IPin_iface, &sink_pin.IPin_iface, NULL); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(source_pin.peer == &sink_pin.IPin_iface, "Got peer %p.\n", source_pin.peer); + ok(!source_pin.mt, "Got mt %p.\n", source_pin.mt); + ok(!sink_pin.peer, "Got peer %p.\n", sink_pin.peer); + IPin_AddRef(sink_pin.peer = &source_pin.IPin_iface); + + hr = IFilterGraph2_Release(graph); + ok(!hr, "Got outstanding refcount %d.\n", hr); + ok(source.ref == 1, "Got outstanding refcount %d.\n", source.ref); + ok(sink.ref == 1, "Got outstanding refcount %d.\n", sink.ref); + ok(source_pin.ref == 1, "Got outstanding refcount %d.\n", source_pin.ref); +todo_wine + ok(sink_pin.ref == 1, "Got outstanding refcount %d.\n", sink_pin.ref); + ok(!source_pin.peer, "Got peer %p.\n", source_pin.peer); + ok(!sink_pin.peer, "Got peer %p.\n", sink_pin.peer); +} + START_TEST(filtergraph) { CoInitializeEx(NULL, COINIT_MULTITHREADED); @@ -1876,6 +2027,7 @@ START_TEST(filtergraph) test_aggregate_filter_graph(); test_control_delegation(); test_add_remove_filter(); + test_connect_direct(); CoUninitialize(); test_render_with_multithread(); -- 2.7.4

2 5

[PATCH v2] user32: Make sure that passed window handle is scroll control before accessing wExtra in SCROLL_GetInternalInfo.
by Jacek Caban 20 Sep '18

20 Sep '18

Fixes memory corruption in Office 2016. Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/user32/scroll.c | 3 ++- dlls/user32/tests/scroll.c | 21 +++++++++++++++++++++ 2 files changed, 23 insertions(+), 1 deletion(-)

1 0

[PATCH 5/5] wined3d: Store max_clip_distances in struct d3d_info.
by Józef Kucia 20 Sep '18

20 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/adapter_gl.c | 1 + dlls/wined3d/device.c | 4 ++-- dlls/wined3d/wined3d_private.h | 1 + 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index 0198a97d6022..e0c1954f69d1 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -3651,6 +3651,7 @@ static BOOL wined3d_adapter_init_gl_caps(struct wined3d_adapter *adapter, adapter->fragment_pipe = select_fragment_implementation(gl_info, adapter->shader_backend); d3d_info->limits.max_rt_count = gl_info->limits.buffers; + d3d_info->limits.max_clip_distances = gl_info->limits.user_clip_distances; d3d_info->limits.pointsize_max = gl_info->limits.pointsize_max; adapter->shader_backend->shader_get_caps(gl_info, &shader_caps); diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index 96e7a3dbfaa6..3fc3ae557dc6 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -1762,7 +1762,7 @@ HRESULT CDECL wined3d_device_set_clip_plane(struct wined3d_device *device, { TRACE("device %p, plane_idx %u, plane %p.\n", device, plane_idx, plane); - if (plane_idx >= device->adapter->gl_info.limits.user_clip_distances) + if (plane_idx >= device->adapter->d3d_info.limits.max_clip_distances) { TRACE("Application has requested clipplane this device doesn't support.\n"); return WINED3DERR_INVALIDCALL; @@ -1790,7 +1790,7 @@ HRESULT CDECL wined3d_device_get_clip_plane(const struct wined3d_device *device, { TRACE("device %p, plane_idx %u, plane %p.\n", device, plane_idx, plane); - if (plane_idx >= device->adapter->gl_info.limits.user_clip_distances) + if (plane_idx >= device->adapter->d3d_info.limits.max_clip_distances) { TRACE("Application has requested clipplane this device doesn't support.\n"); return WINED3DERR_INVALIDCALL; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 2a5a0eceeb98..122d4c7825de 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -165,6 +165,7 @@ struct wined3d_d3d_limits unsigned int active_light_count; unsigned int max_rt_count; + unsigned int max_clip_distances; float pointsize_max; }; -- 2.16.4

2 1

[PATCH 4/5] wined3d: Allocate memory for formats in wined3d_adapter_init_format_info().
by Józef Kucia 20 Sep '18

20 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/utils.c | 42 +++++++++++++++++++++--------------------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 9627b13e8e9a..bf32953032ea 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -1994,23 +1994,15 @@ static enum wined3d_channel_type map_channel_type(char t) } } -static BOOL init_format_base_info(struct wined3d_adapter *adapter, size_t format_size) +static BOOL init_format_base_info(struct wined3d_adapter *adapter) { struct wined3d_format *format; unsigned int i, j; - adapter->format_size = format_size; - if (!(adapter->formats = heap_calloc(WINED3D_FORMAT_COUNT - + ARRAY_SIZE(typeless_depth_stencil_formats), adapter->format_size))) - { - ERR("Failed to allocate memory.\n"); - return FALSE; - } - for (i = 0; i < ARRAY_SIZE(formats); ++i) { if (!(format = get_format_internal(adapter, formats[i].id))) - goto fail; + return FALSE; format->id = formats[i].id; format->red_size = formats[i].red_size; @@ -2036,10 +2028,10 @@ static BOOL init_format_base_info(struct wined3d_adapter *adapter, size_t format DWORD flags = 0; if (!(format = get_format_internal(adapter, typed_formats[i].id))) - goto fail; + return FALSE; if (!(typeless_format = get_format_internal(adapter, typed_formats[i].typeless_id))) - goto fail; + return FALSE; format->id = typed_formats[i].id; format->red_size = typeless_format->red_size; @@ -2087,7 +2079,7 @@ static BOOL init_format_base_info(struct wined3d_adapter *adapter, size_t format for (i = 0; i < ARRAY_SIZE(ddi_formats); ++i) { if (!(format = get_format_internal(adapter, ddi_formats[i].id))) - goto fail; + return FALSE; format->ddi_format = ddi_formats[i].ddi_format; } @@ -2095,16 +2087,12 @@ static BOOL init_format_base_info(struct wined3d_adapter *adapter, size_t format for (i = 0; i < ARRAY_SIZE(format_base_flags); ++i) { if (!(format = get_format_internal(adapter, format_base_flags[i].id))) - goto fail; + return FALSE; format_set_flag(format, format_base_flags[i].flags); } return TRUE; - -fail: - heap_free(adapter->formats); - return FALSE; } static BOOL init_format_block_info(struct wined3d_adapter *adapter) @@ -3951,9 +3939,21 @@ static void init_format_depth_bias_scale(struct wined3d_adapter *adapter, BOOL wined3d_adapter_init_format_info(struct wined3d_adapter *adapter, size_t format_size) { - if (!init_format_base_info(adapter, format_size)) return FALSE; - if (!init_format_block_info(adapter)) goto fail; - if (!init_format_decompress_info(adapter)) goto fail; + unsigned int count = WINED3D_FORMAT_COUNT + ARRAY_SIZE(typeless_depth_stencil_formats); + + if (!(adapter->formats = heap_calloc(count, format_size))) + { + ERR("Failed to allocate memory.\n"); + return FALSE; + } + adapter->format_size = format_size; + + if (!init_format_base_info(adapter)) + goto fail; + if (!init_format_block_info(adapter)) + goto fail; + if (!init_format_decompress_info(adapter)) + goto fail; return TRUE; -- 2.16.4

2 1

[PATCH 3/5] wined3d: Add support for variable-sized format structures.
by Józef Kucia 20 Sep '18

20 Sep '18

In order to move GL-specific fields into their own structure. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/directx.c | 2 +- dlls/wined3d/utils.c | 28 +++++++++++++++------------- dlls/wined3d/wined3d_private.h | 5 +++-- 3 files changed, 19 insertions(+), 16 deletions(-) diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 020b57d35916..f4e1621e579f 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2491,7 +2491,7 @@ static BOOL wined3d_adapter_no3d_init(struct wined3d_adapter *adapter) adapter->vram_bytes_used = 0; TRACE("Emulating 0x%s bytes of video ram.\n", wine_dbgstr_longlong(adapter->vram_bytes)); - if (!wined3d_adapter_init_format_info(adapter)) + if (!wined3d_adapter_init_format_info(adapter, sizeof(struct wined3d_format))) return FALSE; adapter->vertex_pipe = &none_vertex_pipe; diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 4f9fc131f911..9627b13e8e9a 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -1927,7 +1927,7 @@ static inline int get_format_idx(enum wined3d_format_id format_id) static struct wined3d_format *get_format_by_idx(const struct wined3d_adapter *adapter, int fmt_idx) { - return &adapter->formats[fmt_idx]; + return (struct wined3d_format *)((BYTE *)adapter->formats + fmt_idx * adapter->format_size); } static struct wined3d_format *get_format_internal(const struct wined3d_adapter *adapter, @@ -1944,10 +1944,11 @@ static struct wined3d_format *get_format_internal(const struct wined3d_adapter * return get_format_by_idx(adapter, fmt_idx); } -static void copy_format(struct wined3d_format *dst_format, const struct wined3d_format *src_format) +static void copy_format(const struct wined3d_adapter *adapter, + struct wined3d_format *dst_format, const struct wined3d_format *src_format) { enum wined3d_format_id id = dst_format->id; - *dst_format = *src_format; + memcpy(dst_format, src_format, adapter->format_size); dst_format->id = id; } @@ -1993,13 +1994,14 @@ static enum wined3d_channel_type map_channel_type(char t) } } -static BOOL init_format_base_info(struct wined3d_adapter *adapter) +static BOOL init_format_base_info(struct wined3d_adapter *adapter, size_t format_size) { struct wined3d_format *format; unsigned int i, j; + adapter->format_size = format_size; if (!(adapter->formats = heap_calloc(WINED3D_FORMAT_COUNT - + ARRAY_SIZE(typeless_depth_stencil_formats), sizeof(*adapter->formats)))) + + ARRAY_SIZE(typeless_depth_stencil_formats), adapter->format_size))) { ERR("Failed to allocate memory.\n"); return FALSE; @@ -3198,7 +3200,7 @@ static BOOL init_format_texture_info(struct wined3d_adapter *adapter, struct win if (!srgb_format) continue; - copy_format(srgb_format, format); + copy_format(adapter, srgb_format, format); if (gl_info->supported[EXT_TEXTURE_SRGB] && !(adapter->d3d_info.wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL)) @@ -3716,7 +3718,7 @@ static BOOL init_typeless_formats(const struct wined3d_adapter *adapter) return FALSE; memcpy(flags, typeless_format->flags, sizeof(flags)); - copy_format(typeless_format, format); + copy_format(adapter, typeless_format, format); for (j = 0; j < ARRAY_SIZE(typeless_format->flags); ++j) typeless_format->flags[j] |= flags[j]; } @@ -3734,7 +3736,7 @@ static BOOL init_typeless_formats(const struct wined3d_adapter *adapter) typeless_ds_format = get_format_by_idx(adapter, WINED3D_FORMAT_COUNT + i); typeless_ds_format->id = typeless_depth_stencil_formats[i].typeless_id; - copy_format(typeless_ds_format, ds_format); + copy_format(adapter, typeless_ds_format, ds_format); for (j = 0; j < ARRAY_SIZE(typeless_ds_format->flags); ++j) { typeless_ds_format->flags[j] = typeless_format->flags[j]; @@ -3746,13 +3748,13 @@ static BOOL init_typeless_formats(const struct wined3d_adapter *adapter) { if (!(depth_view_format = get_format_internal(adapter, format_id))) return FALSE; - copy_format(depth_view_format, ds_format); + copy_format(adapter, depth_view_format, ds_format); } if ((format_id = typeless_depth_stencil_formats[i].stencil_view_id)) { if (!(stencil_view_format = get_format_internal(adapter, format_id))) return FALSE; - copy_format(stencil_view_format, ds_format); + copy_format(adapter, stencil_view_format, ds_format); } } @@ -3947,9 +3949,9 @@ static void init_format_depth_bias_scale(struct wined3d_adapter *adapter, } } -BOOL wined3d_adapter_init_format_info(struct wined3d_adapter *adapter) +BOOL wined3d_adapter_init_format_info(struct wined3d_adapter *adapter, size_t format_size) { - if (!init_format_base_info(adapter)) return FALSE; + if (!init_format_base_info(adapter, format_size)) return FALSE; if (!init_format_block_info(adapter)) goto fail; if (!init_format_decompress_info(adapter)) goto fail; @@ -3966,7 +3968,7 @@ BOOL wined3d_adapter_gl_init_format_info(struct wined3d_adapter *adapter, struct { struct wined3d_gl_info *gl_info = &adapter->gl_info; - if (!wined3d_adapter_init_format_info(adapter)) + if (!wined3d_adapter_init_format_info(adapter, sizeof(struct wined3d_format))) return FALSE; if (!init_format_texture_info(adapter, gl_info)) goto fail; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 1e215fe95c11..2a5a0eceeb98 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2667,7 +2667,8 @@ struct wined3d_adapter UINT64 vram_bytes_used; LUID luid; - struct wined3d_format *formats; + void *formats; + size_t format_size; const struct wined3d_vertex_pipe_ops *vertex_pipe; const struct fragment_pipeline *fragment_pipe; @@ -2690,7 +2691,7 @@ struct wined3d_caps_gl_ctx GLuint test_program_id; }; -BOOL wined3d_adapter_init_format_info(struct wined3d_adapter *adapter) DECLSPEC_HIDDEN; +BOOL wined3d_adapter_init_format_info(struct wined3d_adapter *adapter, size_t format_size) DECLSPEC_HIDDEN; BOOL wined3d_adapter_gl_init_format_info(struct wined3d_adapter *adapter, struct wined3d_caps_gl_ctx *ctx) DECLSPEC_HIDDEN; UINT64 adapter_adjust_memory(struct wined3d_adapter *adapter, INT64 amount) DECLSPEC_HIDDEN; -- 2.16.4

2 1

[PATCH 2/5] wined3d: Introduce separate function for OpenGL formats initialisation.
by Józef Kucia 20 Sep '18

20 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/adapter_gl.c | 2 +- dlls/wined3d/directx.c | 2 +- dlls/wined3d/utils.c | 22 ++++++++++++++++------ dlls/wined3d/wined3d_private.h | 3 ++- 4 files changed, 20 insertions(+), 9 deletions(-) diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index e60383cce3b5..0198a97d6022 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -4279,7 +4279,7 @@ BOOL wined3d_adapter_opengl_init(struct wined3d_adapter *adapter, DWORD wined3d_ return FALSE; } - if (!wined3d_adapter_init_format_info(adapter, &caps_gl_ctx)) + if (!wined3d_adapter_gl_init_format_info(adapter, &caps_gl_ctx)) { ERR("Failed to initialize GL format info.\n"); wined3d_caps_gl_ctx_destroy(&caps_gl_ctx); diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 81c3b5d492d9..020b57d35916 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2491,7 +2491,7 @@ static BOOL wined3d_adapter_no3d_init(struct wined3d_adapter *adapter) adapter->vram_bytes_used = 0; TRACE("Emulating 0x%s bytes of video ram.\n", wine_dbgstr_longlong(adapter->vram_bytes)); - if (!wined3d_adapter_init_format_info(adapter, NULL)) + if (!wined3d_adapter_init_format_info(adapter)) return FALSE; adapter->vertex_pipe = &none_vertex_pipe; diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index a7bcedffba8e..4f9fc131f911 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -3947,17 +3947,27 @@ static void init_format_depth_bias_scale(struct wined3d_adapter *adapter, } } -/* Context activation is done by the caller. */ -BOOL wined3d_adapter_init_format_info(struct wined3d_adapter *adapter, struct wined3d_caps_gl_ctx *ctx) +BOOL wined3d_adapter_init_format_info(struct wined3d_adapter *adapter) { - struct wined3d_gl_info *gl_info = &adapter->gl_info; - if (!init_format_base_info(adapter)) return FALSE; if (!init_format_block_info(adapter)) goto fail; if (!init_format_decompress_info(adapter)) goto fail; - if (!ctx) /* WINED3D_NO3D */ - return TRUE; + return TRUE; + +fail: + heap_free(adapter->formats); + adapter->formats = NULL; + return FALSE; +} + +/* Context activation is done by the caller. */ +BOOL wined3d_adapter_gl_init_format_info(struct wined3d_adapter *adapter, struct wined3d_caps_gl_ctx *ctx) +{ + struct wined3d_gl_info *gl_info = &adapter->gl_info; + + if (!wined3d_adapter_init_format_info(adapter)) + return FALSE; if (!init_format_texture_info(adapter, gl_info)) goto fail; if (!init_format_vertex_info(adapter, gl_info)) goto fail; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 89cf44bcd4fe..1e215fe95c11 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2690,7 +2690,8 @@ struct wined3d_caps_gl_ctx GLuint test_program_id; }; -BOOL wined3d_adapter_init_format_info(struct wined3d_adapter *adapter, +BOOL wined3d_adapter_init_format_info(struct wined3d_adapter *adapter) DECLSPEC_HIDDEN; +BOOL wined3d_adapter_gl_init_format_info(struct wined3d_adapter *adapter, struct wined3d_caps_gl_ctx *ctx) DECLSPEC_HIDDEN; UINT64 adapter_adjust_memory(struct wined3d_adapter *adapter, INT64 amount) DECLSPEC_HIDDEN; -- 2.16.4

2 1

[PATCH 1/5] wined3d: Introduce get_format_by_idx() helper function.
by Józef Kucia 20 Sep '18

20 Sep '18

In preparation for variable-sized format structures. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/utils.c | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index d190c896690e..a7bcedffba8e 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -1925,6 +1925,11 @@ static inline int get_format_idx(enum wined3d_format_id format_id) return -1; } +static struct wined3d_format *get_format_by_idx(const struct wined3d_adapter *adapter, int fmt_idx) +{ + return &adapter->formats[fmt_idx]; +} + static struct wined3d_format *get_format_internal(const struct wined3d_adapter *adapter, enum wined3d_format_id format_id) { @@ -1936,7 +1941,7 @@ static struct wined3d_format *get_format_internal(const struct wined3d_adapter * return NULL; } - return &adapter->formats[fmt_idx]; + return get_format_by_idx(adapter, fmt_idx); } static void copy_format(struct wined3d_format *dst_format, const struct wined3d_format *src_format) @@ -2729,8 +2734,8 @@ static void init_format_fbo_compat_info(const struct wined3d_adapter *adapter, { for (i = 0; i < WINED3D_FORMAT_COUNT; ++i) { + struct wined3d_format *format = get_format_by_idx(adapter, i); BOOL fallback_fmt_used = FALSE, regular_fmt_used = FALSE; - struct wined3d_format *format = &adapter->formats[i]; GLenum rt_internal = format->rtInternal; GLint value; @@ -2843,7 +2848,7 @@ static void init_format_fbo_compat_info(const struct wined3d_adapter *adapter, for (i = 0; i < WINED3D_FORMAT_COUNT; ++i) { - struct wined3d_format *format = &adapter->formats[i]; + struct wined3d_format *format = get_format_by_idx(adapter, i); if (!format->glInternal) continue; @@ -3629,7 +3634,7 @@ static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_ for (i = 0; i < WINED3D_FORMAT_COUNT; ++i) { - struct wined3d_format *format = &adapter->formats[i]; + struct wined3d_format *format = get_format_by_idx(adapter, i); if (!(format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_TEXTURE)) continue; @@ -3727,7 +3732,7 @@ static BOOL init_typeless_formats(const struct wined3d_adapter *adapter) if (!(ds_format = get_format_internal(adapter, typeless_depth_stencil_formats[i].depth_stencil_id))) return FALSE; - typeless_ds_format = &adapter->formats[WINED3D_FORMAT_COUNT + i]; + typeless_ds_format = get_format_by_idx(adapter, WINED3D_FORMAT_COUNT + i); typeless_ds_format->id = typeless_depth_stencil_formats[i].typeless_id; copy_format(typeless_ds_format, ds_format); for (j = 0; j < ARRAY_SIZE(typeless_ds_format->flags); ++j) @@ -3764,7 +3769,7 @@ static void init_format_gen_mipmap_info(const struct wined3d_adapter *adapter, for (i = 0; i < WINED3D_FORMAT_COUNT; ++i) { - struct wined3d_format *format = &adapter->formats[i]; + struct wined3d_format *format = get_format_by_idx(adapter, i); for (j = 0; j < ARRAY_SIZE(format->flags); ++j) if (!(~format->flags[j] & (WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_FILTERING))) @@ -3921,7 +3926,7 @@ static void init_format_depth_bias_scale(struct wined3d_adapter *adapter, for (i = 0; i < WINED3D_FORMAT_COUNT; ++i) { - struct wined3d_format *format = &adapter->formats[i]; + struct wined3d_format *format = get_format_by_idx(adapter, i); if (format->flags[WINED3D_GL_RES_TYPE_RB] & WINED3DFMT_FLAG_DEPTH) { @@ -3987,14 +3992,14 @@ const struct wined3d_format *wined3d_get_format(const struct wined3d_adapter *ad return get_format_internal(adapter, WINED3DFMT_UNKNOWN); } - format = &adapter->formats[idx]; + format = get_format_by_idx(adapter, idx); if (resource_usage & WINED3DUSAGE_DEPTHSTENCIL && wined3d_format_is_typeless(format)) { for (i = 0; i < ARRAY_SIZE(typeless_depth_stencil_formats); ++i) { if (typeless_depth_stencil_formats[i].typeless_id == format_id) - return &adapter->formats[WINED3D_FORMAT_COUNT + i]; + return get_format_by_idx(adapter, WINED3D_FORMAT_COUNT + i); } FIXME("Cannot find depth/stencil typeless format %s (%#x).\n", -- 2.16.4

2 1

[PATCH] winmm: Use the ARRAY_SIZE() macro
by Michael Stefaniuc 20 Sep '18

20 Sep '18

Signed-off-by: Michael Stefaniuc <mstefani(a)winehq.org> --- dlls/winmm/driver.c | 2 +- dlls/winmm/lolvldrv.c | 10 +++++----- dlls/winmm/mci.c | 20 +++++++++----------- dlls/winmm/mmio.c | 2 +- dlls/winmm/playsound.c | 10 +++++----- dlls/winmm/waveform.c | 2 +- dlls/winmm/winmm.c | 3 +-- 7 files changed, 23 insertions(+), 26 deletions(-) diff --git a/dlls/winmm/driver.c b/dlls/winmm/driver.c index feecc92122..0117c60496 100644 --- a/dlls/winmm/driver.c +++ b/dlls/winmm/driver.c @@ -396,7 +396,7 @@ HDRVR WINAPI OpenDriver(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lPar if (lsn == NULL) { static const WCHAR wszDrivers32[] = {'D','r','i','v','e','r','s','3','2',0}; - lstrcpynW(libName, lpDriverName, sizeof(libName) / sizeof(WCHAR)); + lstrcpynW(libName, lpDriverName, ARRAY_SIZE(libName)); if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam))) goto the_end; diff --git a/dlls/winmm/lolvldrv.c b/dlls/winmm/lolvldrv.c index 35bd6a0b5f..95f454f31d 100644 --- a/dlls/winmm/lolvldrv.c +++ b/dlls/winmm/lolvldrv.c @@ -181,7 +181,7 @@ void MMDRV_Free(HANDLE hndl, LPWINE_MLD mld) if ((UINT_PTR)hndl & 0x8000) { UINT_PTR idx = (UINT_PTR)hndl & ~0x8000; - if (idx < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0])) { + if (idx < ARRAY_SIZE(MM_MLDrvs)) { MM_MLDrvs[idx] = NULL; HeapFree(GetProcessHeap(), 0, mld); return; @@ -261,7 +261,7 @@ LPWINE_MLD MMDRV_Get(HANDLE _hndl, UINT type, BOOL bCanBeID) hndl != (UINT16)-1 && hndl != (UINT)-1) { if (hndl & 0x8000) { UINT idx = hndl & ~0x8000; - if (idx < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0])) { + if (idx < ARRAY_SIZE(MM_MLDrvs)) { __TRY { mld = MM_MLDrvs[idx]; @@ -424,7 +424,7 @@ static BOOL MMDRV_Install(LPCSTR drvRegName, LPCSTR drvFileName, BOOL bIsMapper) * drivers !! * If not just increase size of MMDrvs */ - assert(MMDrvsHi <= sizeof(MMDrvs)/sizeof(MMDrvs[0])); + assert(MMDrvsHi <= ARRAY_SIZE(MMDrvs)); memset(lpDrv, 0, sizeof(*lpDrv)); @@ -589,7 +589,7 @@ void MMDRV_Exit(void) unsigned int i; TRACE("()\n"); - for (i = 0; i < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0]); i++) + for (i = 0; i < ARRAY_SIZE(MM_MLDrvs); i++) { if (MM_MLDrvs[i] != NULL) { @@ -602,7 +602,7 @@ void MMDRV_Exit(void) } /* unload driver, in reverse order of loading */ - i = sizeof(MMDrvs) / sizeof(MMDrvs[0]); + i = ARRAY_SIZE(MMDrvs); while (i-- > 0) { MMDRV_ExitPerType(&MMDrvs[i], MMDRV_AUX); diff --git a/dlls/winmm/mci.c b/dlls/winmm/mci.c index 56a537d79c..0319a0b16c 100644 --- a/dlls/winmm/mci.c +++ b/dlls/winmm/mci.c @@ -551,7 +551,7 @@ static UINT MCI_GetDevTypeFromResource(LPCWSTR lpstrName) WCHAR buf[32]; UINT uDevType; for (uDevType = MCI_DEVTYPE_FIRST; uDevType <= MCI_DEVTYPE_LAST; uDevType++) { - if (LoadStringW(hWinMM32Instance, uDevType, buf, sizeof(buf) / sizeof(WCHAR))) { + if (LoadStringW(hWinMM32Instance, uDevType, buf, ARRAY_SIZE(buf))) { /* FIXME: ignore digits suffix */ if (!strcmpiW(buf, lpstrName)) return uDevType; @@ -668,7 +668,7 @@ static UINT MCI_GetCommandTable(UINT uDevType) /* well try to load id */ if (uDevType >= MCI_DEVTYPE_FIRST && uDevType <= MCI_DEVTYPE_LAST) { - if (LoadStringW(hWinMM32Instance, uDevType, buf, sizeof(buf) / sizeof(WCHAR))) { + if (LoadStringW(hWinMM32Instance, uDevType, buf, ARRAY_SIZE(buf))) { str = buf; } } else if (uDevType == 0) { @@ -1450,9 +1450,9 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet, { static const WCHAR wszOpenWait[] = {'o','p','e','n',' ','%','s',' ','w','a','i','t',0}; WCHAR buf[138], retbuf[6]; - snprintfW(buf, sizeof(buf)/sizeof(WCHAR), wszOpenWait, dev); + snprintfW(buf, ARRAY_SIZE(buf), wszOpenWait, dev); /* open via mciSendString handles quoting, dev!file syntax and alias creation */ - if ((dwRet = mciSendStringW(buf, retbuf, sizeof(retbuf)/sizeof(WCHAR), 0)) != 0) + if ((dwRet = mciSendStringW(buf, retbuf, ARRAY_SIZE(retbuf), 0)) != 0) goto errCleanUp; auto_open = strtoulW(retbuf, NULL, 10); TRACE("auto-opened %u for %s\n", auto_open, debugstr_w(dev)); @@ -1746,10 +1746,8 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSW lpParms) if (dwParam & MCI_OPEN_TYPE_ID) { WORD uDevType = LOWORD(lpParms->lpstrDeviceType); - if (uDevType < MCI_DEVTYPE_FIRST || - uDevType > MCI_DEVTYPE_LAST || - !LoadStringW(hWinMM32Instance, uDevType, - strDevTyp, sizeof(strDevTyp) / sizeof(WCHAR))) { + if (uDevType < MCI_DEVTYPE_FIRST || uDevType > MCI_DEVTYPE_LAST || + !LoadStringW(hWinMM32Instance, uDevType, strDevTyp, ARRAY_SIZE(strDevTyp))) { dwRet = MCIERR_BAD_INTEGER; goto errCleanUp; } @@ -1946,7 +1944,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm RegQueryInfoKeyW( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0); RegCloseKey( hKey ); } - if (GetPrivateProfileStringW(wszMci, 0, wszNull, buf, sizeof(buf) / sizeof(buf[0]), wszSystemIni)) + if (GetPrivateProfileStringW(wszMci, 0, wszNull, buf, ARRAY_SIZE(buf), wszSystemIni)) for (s = buf; *s; s += strlenW(s) + 1) cnt++; } } else { @@ -2016,7 +2014,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm if (RegQueryInfoKeyW( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0) == ERROR_SUCCESS && lpParms->dwNumber <= cnt) { - DWORD bufLen = sizeof(buf)/sizeof(buf[0]); + DWORD bufLen = ARRAY_SIZE(buf); if (RegEnumKeyExW(hKey, lpParms->dwNumber - 1, buf, &bufLen, 0, 0, 0, 0) == ERROR_SUCCESS) s = buf; @@ -2024,7 +2022,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm RegCloseKey( hKey ); } if (!s) { - if (GetPrivateProfileStringW(wszMci, 0, wszNull, buf, sizeof(buf) / sizeof(buf[0]), wszSystemIni)) { + if (GetPrivateProfileStringW(wszMci, 0, wszNull, buf, ARRAY_SIZE(buf), wszSystemIni)) { for (p = buf; *p; p += strlenW(p) + 1, cnt++) { TRACE("%d: %s\n", cnt, debugstr_w(p)); if (cnt == lpParms->dwNumber - 1) { diff --git a/dlls/winmm/mmio.c b/dlls/winmm/mmio.c index d8af7874f3..b4155b6f51 100644 --- a/dlls/winmm/mmio.c +++ b/dlls/winmm/mmio.c @@ -315,7 +315,7 @@ static LPMMIOPROC MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc, } /* remove it, but only if it isn't builtin */ if ((*ppListNode) >= defaultProcs && - (*ppListNode) < defaultProcs + sizeof(defaultProcs) / sizeof(defaultProcs[0])) { + (*ppListNode) < defaultProcs + ARRAY_SIZE(defaultProcs)) { WARN("Tried to remove built-in mmio proc. Skipping\n"); } else { /* Okay, nuke it */ diff --git a/dlls/winmm/playsound.c b/dlls/winmm/playsound.c index 6525db5c19..2731e7b935 100644 --- a/dlls/winmm/playsound.c +++ b/dlls/winmm/playsound.c @@ -60,7 +60,7 @@ static HMMIO get_mmioFromFile(LPCWSTR lpszName) ret = mmioOpenW((LPWSTR)lpszName, NULL, MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE); if (ret != 0) return ret; - if (SearchPathW(NULL, lpszName, dotwav, sizeof(buf)/sizeof(buf[0]), buf, &dummy)) + if (SearchPathW(NULL, lpszName, dotwav, ARRAY_SIZE(buf), buf, &dummy)) { return mmioOpenW(buf, NULL, MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE); @@ -86,11 +86,11 @@ static HMMIO get_mmioFromProfile(UINT uFlags, LPCWSTR lpszName) static const WCHAR wszNull[] = {0}; TRACE("searching in SystemSound list for %s\n", debugstr_w(lpszName)); - GetProfileStringW(wszSounds, lpszName, wszNull, str, sizeof(str)/sizeof(str[0])); + GetProfileStringW(wszSounds, lpszName, wszNull, str, ARRAY_SIZE(str)); if (lstrlenW(str) == 0) { if (uFlags & SND_NODEFAULT) goto next; - GetProfileStringW(wszSounds, wszDefault, wszNull, str, sizeof(str)/sizeof(str[0])); + GetProfileStringW(wszSounds, wszDefault, wszNull, str, ARRAY_SIZE(str)); if (lstrlenW(str) == 0) goto next; } for (ptr = str; *ptr && *ptr != ','; ptr++); @@ -108,8 +108,8 @@ static HMMIO get_mmioFromProfile(UINT uFlags, LPCWSTR lpszName) DWORD len; err = 1; /* error */ - len = GetModuleFileNameW(0, str, sizeof(str)/sizeof(str[0])); - if (len > 0 && len < sizeof(str)/sizeof(str[0])) + len = GetModuleFileNameW(0, str, ARRAY_SIZE(str)); + if (len > 0 && len < ARRAY_SIZE(str)) { for (ptr = str + lstrlenW(str) - 1; ptr >= str; ptr--) { diff --git a/dlls/winmm/waveform.c b/dlls/winmm/waveform.c index 0a259c0f74..959773cae4 100644 --- a/dlls/winmm/waveform.c +++ b/dlls/winmm/waveform.c @@ -4354,7 +4354,7 @@ UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpmliA, mliW.Target.wMid = lpmliA->Target.wMid; mliW.Target.wPid = lpmliA->Target.wPid; mliW.Target.vDriverVersion = lpmliA->Target.vDriverVersion; - MultiByteToWideChar( CP_ACP, 0, lpmliA->Target.szPname, -1, mliW.Target.szPname, sizeof(mliW.Target.szPname)/sizeof(WCHAR)); + MultiByteToWideChar(CP_ACP, 0, lpmliA->Target.szPname, -1, mliW.Target.szPname, ARRAY_SIZE(mliW.Target.szPname)); break; default: WARN("Unsupported fdwControls=0x%08x\n", fdwInfo); diff --git a/dlls/winmm/winmm.c b/dlls/winmm/winmm.c index 487bbff93b..0f0cd946d1 100644 --- a/dlls/winmm/winmm.c +++ b/dlls/winmm/winmm.c @@ -1445,8 +1445,7 @@ static MMRESULT midistream_post_message_and_wait(WINE_MIDIStream* lpMidiStrm, UI if (GetCurrentThreadId() != lpMidiStrm->dwThreadID) { DWORD ret; hObjects[1] = lpMidiStrm->hThread; - ret = WaitForMultipleObjects(sizeof(hObjects)/sizeof(hObjects[0]), hObjects, - FALSE, INFINITE); + ret = WaitForMultipleObjects(ARRAY_SIZE(hObjects), hObjects, FALSE, INFINITE); if (ret != WAIT_OBJECT_0) { CloseHandle(hObjects[0]); WARN("bad WaitForSingleObject (%u)\n", ret); -- 2.14.4

2 1

[PATCH v2] imm32: Avoid using GCC's typeof extension
by Alex Henrie 20 Sep '18

20 Sep '18

Signed-off-by: Alex Henrie <alexhenrie24(a)gmail.com> --- dlls/imm32/imm.c | 34 ++++++++++++++++------------------ 1 file changed, 16 insertions(+), 18 deletions(-) diff --git a/dlls/imm32/imm.c b/dlls/imm32/imm.c index f235e228ad..28eb00f355 100644 --- a/dlls/imm32/imm.c +++ b/dlls/imm32/imm.c @@ -40,7 +40,6 @@ WINE_DEFAULT_DEBUG_CHANNEL(imm); #define IMM_INIT_MAGIC 0x19650412 BOOL WINAPI User32InitializeImmEntryTable(DWORD); -#define MAKE_FUNCPTR(f) typeof(f) * p##f typedef struct _tagImmHkl{ struct list entry; HKL hkl; @@ -51,24 +50,23 @@ typedef struct _tagImmHkl{ HWND UIWnd; /* Function Pointers */ - MAKE_FUNCPTR(ImeInquire); - MAKE_FUNCPTR(ImeConfigure); - MAKE_FUNCPTR(ImeDestroy); - MAKE_FUNCPTR(ImeEscape); - MAKE_FUNCPTR(ImeSelect); - MAKE_FUNCPTR(ImeSetActiveContext); - MAKE_FUNCPTR(ImeToAsciiEx); - MAKE_FUNCPTR(NotifyIME); - MAKE_FUNCPTR(ImeRegisterWord); - MAKE_FUNCPTR(ImeUnregisterWord); - MAKE_FUNCPTR(ImeEnumRegisterWord); - MAKE_FUNCPTR(ImeSetCompositionString); - MAKE_FUNCPTR(ImeConversionList); - MAKE_FUNCPTR(ImeProcessKey); - MAKE_FUNCPTR(ImeGetRegisterWordStyle); - MAKE_FUNCPTR(ImeGetImeMenuItems); + BOOL (WINAPI *pImeInquire)(IMEINFO *, WCHAR *, const WCHAR *); + BOOL (WINAPI *pImeConfigure)(HKL, HWND, DWORD, void *); + BOOL (WINAPI *pImeDestroy)(UINT); + LRESULT (WINAPI *pImeEscape)(HIMC, UINT, void *); + BOOL (WINAPI *pImeSelect)(HIMC, BOOL); + BOOL (WINAPI *pImeSetActiveContext)(HIMC, BOOL); + UINT (WINAPI *pImeToAsciiEx)(UINT, UINT, const BYTE *, DWORD *, UINT, HIMC); + BOOL (WINAPI *pNotifyIME)(HIMC, DWORD, DWORD, DWORD); + BOOL (WINAPI *pImeRegisterWord)(const WCHAR *, DWORD, const WCHAR *); + BOOL (WINAPI *pImeUnregisterWord)(const WCHAR *, DWORD, const WCHAR *); + UINT (WINAPI *pImeEnumRegisterWord)(REGISTERWORDENUMPROCW, const WCHAR *, DWORD, const WCHAR *, void *); + BOOL (WINAPI *pImeSetCompositionString)(HIMC, DWORD, const void *, DWORD, const void *, DWORD); + DWORD (WINAPI *pImeConversionList)(HIMC, const WCHAR *, CANDIDATELIST *, DWORD, UINT); + BOOL (WINAPI *pImeProcessKey)(HIMC, UINT, LPARAM, const BYTE *); + UINT (WINAPI *pImeGetRegisterWordStyle)(UINT, STYLEBUFW *); + DWORD (WINAPI *pImeGetImeMenuItems)(HIMC, DWORD, DWORD, IMEMENUITEMINFOW *, IMEMENUITEMINFOW *, DWORD); } ImmHkl; -#undef MAKE_FUNCPTR typedef struct tagInputContextData { -- 2.19.0

2 1

[PATCH] setupapi: For consistency use __x86_64__ instead of __x86_64.
by Huw Davies 20 Sep '18

20 Sep '18

Spotted by Ken Thomases. Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/setupapi/install.c | 2 +- dlls/setupapi/query.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/setupapi/install.c b/dlls/setupapi/install.c index 5b2d4b8ee3..1453f52247 100644 --- a/dlls/setupapi/install.c +++ b/dlls/setupapi/install.c @@ -1200,7 +1200,7 @@ void WINAPI InstallHinfSectionW( HWND hwnd, HINSTANCE handle, LPCWSTR cmdline, I { #ifdef __i386__ static const WCHAR nt_platformW[] = {'.','n','t','x','8','6',0}; -#elif defined(__x86_64) +#elif defined(__x86_64__) static const WCHAR nt_platformW[] = {'.','n','t','a','m','d','6','4',0}; #else /* FIXME: other platforms */ static const WCHAR nt_platformW[] = {'.','n','t',0}; diff --git a/dlls/setupapi/query.c b/dlls/setupapi/query.c index 627c543d6b..ba6d01dc63 100644 --- a/dlls/setupapi/query.c +++ b/dlls/setupapi/query.c @@ -38,7 +38,7 @@ static const WCHAR source_disks_names_platform[] = {'S','o','u','r','c','e','D','i','s','k','s','N','a','m','e','s','.','x','8','6',0}; static const WCHAR source_disks_files_platform[] = {'S','o','u','r','c','e','D','i','s','k','s','F','i','l','e','s','.','x','8','6',0}; -#elif defined(__x86_64) +#elif defined(__x86_64__) static const WCHAR source_disks_names_platform[] = {'S','o','u','r','c','e','D','i','s','k','s','N','a','m','e','s','.','a','m','d','6','4',0}; static const WCHAR source_disks_files_platform[] = -- 2.18.0

1 0

[PATCH 6/6] wsdapi: Prefer Wine version.
by Owen Rudge 20 Sep '18

20 Sep '18

Signed-off-by: Owen Rudge <orudge(a)codeweavers.com> --- dlls/wsdapi/main.c | 2 -- 1 file changed, 2 deletions(-)

2 1

[PATCH 5/6] wsdapi: Don't include null character at the end of sent messages.
by Owen Rudge 20 Sep '18

20 Sep '18

Signed-off-by: Owen Rudge <orudge(a)codeweavers.com> --- dlls/wsdapi/soap.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)

2 1

[PATCH 4/6] wsdapi: Send Probe Matches message via UDP unicast.
by Owen Rudge 20 Sep '18

20 Sep '18

Signed-off-by: Owen Rudge <orudge(a)codeweavers.com> --- dlls/wsdapi/network.c | 32 ++++++++++++++++++++++++++++++++ dlls/wsdapi/soap.c | 4 ++-- dlls/wsdapi/tests/discovery.c | 22 +++++++++++----------- dlls/wsdapi/wsdapi_internal.h | 1 + 4 files changed, 46 insertions(+), 13 deletions(-)

2 1

[PATCH 3/6] wsdapi: Implement generation of ProbeMatches message.
by Owen Rudge 20 Sep '18

20 Sep '18

Signed-off-by: Owen Rudge <orudge(a)codeweavers.com> --- dlls/wsdapi/soap.c | 169 +++++++++++++++++++++++++++++++++- dlls/wsdapi/tests/discovery.c | 2 +- 2 files changed, 169 insertions(+), 2 deletions(-)

2 1

[PATCH 2/6] wsdapi: Implement matching of names in MatchProbeEx.
by Owen Rudge 20 Sep '18

20 Sep '18

Signed-off-by: Owen Rudge <orudge(a)codeweavers.com> --- dlls/wsdapi/discovery.c | 58 ++++++++++++++++++++++++++++++++--- dlls/wsdapi/soap.c | 9 ++++++ dlls/wsdapi/wsdapi_internal.h | 6 ++++ 3 files changed, 69 insertions(+), 4 deletions(-)

2 1

[PATCH 1/6] wsdapi: Ignore duplicate messages.
by Owen Rudge 20 Sep '18

20 Sep '18

Dropped unrequired critical section -> SRW changes. Signed-off-by: Owen Rudge <orudge(a)codeweavers.com> --- dlls/wsdapi/discovery.c | 13 ++++++++++ dlls/wsdapi/network.c | 2 +- dlls/wsdapi/soap.c | 47 ++++++++++++++++++++++++++++++++++- dlls/wsdapi/wsdapi_internal.h | 11 +++++++- 4 files changed, 70 insertions(+), 3 deletions(-)

2 1

[PATCH 1/4] opcservices: Improve parameter validation in CreateRelationship().
by Nikolay Sivov 20 Sep '18

20 Sep '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/opcservices/package.c | 10 ++++++++++ dlls/opcservices/tests/opcservices.c | 9 ++++++--- 2 files changed, 16 insertions(+), 3 deletions(-) diff --git a/dlls/opcservices/package.c b/dlls/opcservices/package.c index 074f3c8f99..e526ebff67 100644 --- a/dlls/opcservices/package.c +++ b/dlls/opcservices/package.c @@ -1301,13 +1301,23 @@ static HRESULT WINAPI opc_relationship_set_CreateRelationship(IOpcRelationshipSe const WCHAR *type, IUri *target_uri, OPC_URI_TARGET_MODE target_mode, IOpcRelationship **relationship) { struct opc_relationship_set *relationship_set = impl_from_IOpcRelationshipSet(iface); + DWORD length; TRACE("iface %p, id %s, type %s, target_uri %p, target_mode %d, relationship %p.\n", iface, debugstr_w(id), debugstr_w(type), target_uri, target_mode, relationship); + if (!relationship) + return E_POINTER; + + *relationship = NULL; + if (!type || !target_uri) return E_POINTER; + if (IUri_GetPropertyLength(target_uri, Uri_PROPERTY_SCHEME_NAME, &length, 0) == S_OK && length != 0 + && target_mode == OPC_URI_TARGET_MODE_INTERNAL) + return OPC_E_INVALID_RELATIONSHIP_TARGET; + return opc_relationship_create(relationship_set, id, type, target_uri, target_mode, relationship); } diff --git a/dlls/opcservices/tests/opcservices.c b/dlls/opcservices/tests/opcservices.c index 764dca1cf3..c5c8ee2599 100644 --- a/dlls/opcservices/tests/opcservices.c +++ b/dlls/opcservices/tests/opcservices.c @@ -362,21 +362,24 @@ static void test_relationship(void) hr = IOpcPackage_GetRelationshipSet(package, &rels); ok(SUCCEEDED(hr), "Failed to get part set, hr %#x.\n", hr); + rel = (void *)0xdeadbeef; hr = IOpcRelationshipSet_CreateRelationship(rels, NULL, NULL, NULL, OPC_URI_TARGET_MODE_INTERNAL, &rel); ok(hr == E_POINTER, "Unexpected hr %#x.\n", hr); + ok(rel == NULL, "Unexpected instance %p.\n", rel); + rel = (void *)0xdeadbeef; hr = IOpcRelationshipSet_CreateRelationship(rels, NULL, typeW, NULL, OPC_URI_TARGET_MODE_INTERNAL, &rel); ok(hr == E_POINTER, "Unexpected hr %#x.\n", hr); + ok(rel == NULL, "Unexpected instance %p.\n", rel); hr = IOpcRelationshipSet_CreateRelationship(rels, NULL, NULL, target_uri, OPC_URI_TARGET_MODE_INTERNAL, &rel); ok(hr == E_POINTER, "Unexpected hr %#x.\n", hr); /* Absolute target uri with internal mode */ + rel = (void *)0xdeadbeef; hr = IOpcRelationshipSet_CreateRelationship(rels, NULL, typeW, target_uri2, OPC_URI_TARGET_MODE_INTERNAL, &rel); -todo_wine ok(hr == OPC_E_INVALID_RELATIONSHIP_TARGET, "Unexpected hr %#x.\n", hr); - if (hr == S_OK) - IOpcRelationship_Release(rel); + ok(rel == NULL, "Unexpected instance %p.\n", rel); hr = IOpcRelationshipSet_CreateRelationship(rels, NULL, typeW, target_uri, OPC_URI_TARGET_MODE_INTERNAL, &rel); ok(SUCCEEDED(hr), "Failed to create relationship, hr %#x.\n", hr); -- 2.18.0

1 3

[PATCH] Avoid using GCC's typeof extension
by Alex Henrie 20 Sep '18

20 Sep '18

The typeof keyword is a GCC extension that is not part of any standard and not available in MSVC. We should probably stop using typeof everywhere, but these patches just eliminate its use in places where it is both easy to replace and impossible to avoid via ./configure. There are two open bug reports about the use of typeof in Wine: https://bugs.winehq.org/show_bug.cgi?id=20474 https://bugs.winehq.org/show_bug.cgi?id=20476 Alex Henrie (3): d3dcompiler_43/tests: Avoid using GCC's typeof extension gdi32: Avoid using GCC's typeof extension imm32: Avoid using GCC's typeof extension dlls/d3dcompiler_43/tests/blob.c | 6 ++--- dlls/d3dcompiler_43/tests/reflection.c | 2 +- dlls/gdi32/driver.c | 6 ++--- dlls/imm32/imm.c | 34 ++++++++++++-------------- 4 files changed, 23 insertions(+), 25 deletions(-) -- 2.19.0

2 5

[PATCH] gdi32: Avoid using GCC's typeof extension
by Alex Henrie 20 Sep '18

20 Sep '18

Signed-off-by: Alex Henrie <alexhenrie24(a)gmail.com> --- dlls/gdi32/driver.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/dlls/gdi32/driver.c b/dlls/gdi32/driver.c index ce60d110d9..e765d2b360 100644 --- a/dlls/gdi32/driver.c +++ b/dlls/gdi32/driver.c @@ -61,9 +61,9 @@ static CRITICAL_SECTION_DEBUG critsect_debug = }; static CRITICAL_SECTION driver_section = { &critsect_debug, -1, 0, 0, 0, 0 }; -static typeof(GetDesktopWindow) *pGetDesktopWindow; -static typeof(GetSystemMetrics) *pGetSystemMetrics; -static typeof(SetThreadDpiAwarenessContext) *pSetThreadDpiAwarenessContext; +static HWND WINAPI (*pGetDesktopWindow)(void); +static INT WINAPI (*pGetSystemMetrics)(INT); +static DPI_AWARENESS_CONTEXT WINAPI (*pSetThreadDpiAwarenessContext)(DPI_AWARENESS_CONTEXT); /********************************************************************** * create_driver -- 2.19.0

1 0

[PATCH] wmp/tests: Destroy the window before calling CoUninitialize
by Alex Henrie 20 Sep '18

20 Sep '18

Signed-off-by: Alex Henrie <alexhenrie24(a)gmail.com> --- This should fix the crash on Windows Server 2003. --- dlls/wmp/tests/oleobj.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/wmp/tests/oleobj.c b/dlls/wmp/tests/oleobj.c index 2250b75aa9..deac5cd3db 100644 --- a/dlls/wmp/tests/oleobj.c +++ b/dlls/wmp/tests/oleobj.c @@ -1379,11 +1379,11 @@ static void create_container_window(void) START_TEST(oleobj) { - create_container_window(); CoInitialize(NULL); + create_container_window(); test_wmp(); - CoUninitialize(); DestroyWindow(container_hwnd); + CoUninitialize(); } -- 2.19.0

1 0

[PATCH 2/2] wined3d: Disallow creating devices without adapters in wined3d_device_create().
by Henri Verbeet 19 Sep '18

19 Sep '18

These days, we have an adapter even with WINED3D_NO3D. Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/directx.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index d1d80b8b3a7..b6c6ecba410 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2438,12 +2438,11 @@ HRESULT CDECL wined3d_device_create(struct wined3d *wined3d, UINT adapter_idx, e struct wined3d_device *object; HRESULT hr; - TRACE("wined3d %p, adapter_idx %u, device_type %#x, focus_window %p, flags %#x, surface_alignment %u, device_parent %p, device %p.\n", + TRACE("wined3d %p, adapter_idx %u, device_type %#x, focus_window %p, " + "flags %#x, surface_alignment %u, device_parent %p, device %p.\n", wined3d, adapter_idx, device_type, focus_window, flags, surface_alignment, device_parent, device); - /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter - * number and create a device without a 3D adapter for 2D only operation. */ - if (wined3d->adapter_count && adapter_idx >= wined3d->adapter_count) + if (adapter_idx >= wined3d->adapter_count) return WINED3DERR_INVALIDCALL; if (!(object = heap_alloc_zero(sizeof(*object)))) -- 2.11.0

1 0

[PATCH 1/2] wined3d: Rename "wined3d_adapter_opengl" to "wined3d_adapter_gl".
by Henri Verbeet 19 Sep '18

19 Sep '18

For consistency with the filename. Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/adapter_gl.c | 8 ++++---- dlls/wined3d/context.c | 2 +- dlls/wined3d/directx.c | 2 +- dlls/wined3d/wined3d_private.h | 4 ++-- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index e60383cce3b..0948741975e 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -4182,12 +4182,12 @@ static DWORD get_max_gl_version(const struct wined3d_gl_info *gl_info, DWORD fla return wined3d_settings.max_gl_version; } -static const struct wined3d_adapter_ops wined3d_adapter_opengl_ops = +static const struct wined3d_adapter_ops wined3d_adapter_gl_ops = { - wined3d_adapter_opengl_create_context, + wined3d_adapter_gl_create_context, }; -BOOL wined3d_adapter_opengl_init(struct wined3d_adapter *adapter, DWORD wined3d_creation_flags) +BOOL wined3d_adapter_gl_init(struct wined3d_adapter *adapter, DWORD wined3d_creation_flags) { static const DWORD supported_gl_versions[] = { @@ -4290,7 +4290,7 @@ BOOL wined3d_adapter_opengl_init(struct wined3d_adapter *adapter, DWORD wined3d_ wined3d_caps_gl_ctx_destroy(&caps_gl_ctx); wined3d_adapter_init_ffp_attrib_ops(adapter); - adapter->adapter_ops = &wined3d_adapter_opengl_ops; + adapter->adapter_ops = &wined3d_adapter_gl_ops; return TRUE; } diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c index 34376efe3c7..19f0fcbd2b0 100644 --- a/dlls/wined3d/context.c +++ b/dlls/wined3d/context.c @@ -1997,7 +1997,7 @@ out: return NULL; } -BOOL wined3d_adapter_opengl_create_context(struct wined3d_context *context, +BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context, struct wined3d_texture *target, const struct wined3d_format *ds_format) { struct wined3d_device *device = context->device; diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 81c3b5d492d..d1d80b8b3a7 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2525,7 +2525,7 @@ static BOOL wined3d_adapter_init(struct wined3d_adapter *adapter, unsigned int o if (wined3d_creation_flags & WINED3D_NO3D) return wined3d_adapter_no3d_init(adapter); - return wined3d_adapter_opengl_init(adapter, wined3d_creation_flags); + return wined3d_adapter_gl_init(adapter, wined3d_creation_flags); } static void STDMETHODCALLTYPE wined3d_null_wined3d_object_destroyed(void *parent) {} diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 89cf44bcd4f..f01ad173d40 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2647,7 +2647,7 @@ struct wined3d_adapter_ops struct wined3d_texture *target, const struct wined3d_format *ds_format); }; -BOOL wined3d_adapter_opengl_create_context(struct wined3d_context *context, +BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context, struct wined3d_texture *target, const struct wined3d_format *ds_format) DECLSPEC_HIDDEN; /* The adapter structure */ @@ -2675,7 +2675,7 @@ struct wined3d_adapter const struct wined3d_adapter_ops *adapter_ops; }; -BOOL wined3d_adapter_opengl_init(struct wined3d_adapter *adapter, DWORD wined3d_creation_flags) DECLSPEC_HIDDEN; +BOOL wined3d_adapter_gl_init(struct wined3d_adapter *adapter, DWORD wined3d_creation_flags) DECLSPEC_HIDDEN; struct wined3d_caps_gl_ctx { -- 2.11.0

1 0

[PATCH 1/8] wsdapi: Use slim reader/writer lock instead of critical section.
by Owen Rudge 19 Sep '18

19 Sep '18

Signed-off-by: Owen Rudge <orudge(a)codeweavers.com> --- dlls/wsdapi/discovery.c | 13 ++++++------- dlls/wsdapi/network.c | 4 ++-- dlls/wsdapi/wsdapi_internal.h | 2 +- 3 files changed, 9 insertions(+), 10 deletions(-)

4 3

[PATCH] d3dx11: Add D3DX11SaveTextureToFileA/W stub.
by Andrey Gusev 19 Sep '18

19 Sep '18

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=45031 Signed-off-by: Andrey Gusev <andrey.goosev(a)gmail.com> --- dlls/d3dx11_42/d3dx11_42.spec | 4 ++-- dlls/d3dx11_43/d3dx11_43.spec | 4 ++-- dlls/d3dx11_43/texture.c | 18 ++++++++++++++++++ include/d3dx11tex.h | 6 ++++++ 4 files changed, 28 insertions(+), 4 deletions(-) diff --git a/dlls/d3dx11_42/d3dx11_42.spec b/dlls/d3dx11_42/d3dx11_42.spec index cb1f7805ff..033c6a545c 100644 --- a/dlls/d3dx11_42/d3dx11_42.spec +++ b/dlls/d3dx11_42/d3dx11_42.spec @@ -39,6 +39,6 @@ @ stub D3DX11PreprocessShaderFromResourceA @ stub D3DX11PreprocessShaderFromResourceW @ stub D3DX11SHProjectCubeMap -@ stub D3DX11SaveTextureToFileA -@ stub D3DX11SaveTextureToFileW +@ stdcall D3DX11SaveTextureToFileA(ptr ptr long ptr) d3dx11_43.D3DX11SaveTextureToFileA +@ stdcall D3DX11SaveTextureToFileW(ptr ptr long ptr) d3dx11_43.D3DX11SaveTextureToFileW @ stdcall D3DX11SaveTextureToMemory(ptr ptr long ptr long) diff --git a/dlls/d3dx11_43/d3dx11_43.spec b/dlls/d3dx11_43/d3dx11_43.spec index 76a3916e71..61d40fdfc0 100644 --- a/dlls/d3dx11_43/d3dx11_43.spec +++ b/dlls/d3dx11_43/d3dx11_43.spec @@ -39,6 +39,6 @@ @ stub D3DX11PreprocessShaderFromResourceA @ stub D3DX11PreprocessShaderFromResourceW @ stub D3DX11SHProjectCubeMap -@ stub D3DX11SaveTextureToFileA -@ stub D3DX11SaveTextureToFileW +@ stdcall D3DX11SaveTextureToFileA(ptr ptr long ptr) +@ stdcall D3DX11SaveTextureToFileW(ptr ptr long ptr) @ stdcall D3DX11SaveTextureToMemory(ptr ptr long ptr long) diff --git a/dlls/d3dx11_43/texture.c b/dlls/d3dx11_43/texture.c index 6aaf8a7e02..c053e3920f 100644 --- a/dlls/d3dx11_43/texture.c +++ b/dlls/d3dx11_43/texture.c @@ -65,6 +65,24 @@ HRESULT WINAPI D3DX11CreateTextureFromMemory(ID3D11Device *device, const void *d return E_NOTIMPL; } +HRESULT WINAPI D3DX11SaveTextureToFileA(ID3D11DeviceContext *context, ID3D11Resource *texture, + D3DX11_IMAGE_FILE_FORMAT format, const char *dst_filename) +{ + FIXME("context %p, texture %p, format %u, dst_filename %s stub!\n", + context, texture, format, debugstr_a(dst_filename)); + + return E_NOTIMPL; +} + +HRESULT WINAPI D3DX11SaveTextureToFileW(ID3D11DeviceContext *context, ID3D11Resource *texture, + D3DX11_IMAGE_FILE_FORMAT format, const WCHAR *dst_filename) +{ + FIXME("context %p, texture %p, format %u, dst_filename %s stub!\n", + context, texture, format, debugstr_w(dst_filename)); + + return E_NOTIMPL; +} + HRESULT WINAPI D3DX11SaveTextureToMemory(ID3D11DeviceContext *context, ID3D11Resource *texture, D3DX11_IMAGE_FILE_FORMAT format, ID3D10Blob **buffer, UINT flags) { diff --git a/include/d3dx11tex.h b/include/d3dx11tex.h index 4f792ec13e..1dd3933d81 100644 --- a/include/d3dx11tex.h +++ b/include/d3dx11tex.h @@ -127,6 +127,12 @@ HRESULT WINAPI D3DX11FilterTexture(ID3D11DeviceContext *context, ID3D11Resource HRESULT WINAPI D3DX11GetImageInfoFromMemory(const void *src_data, SIZE_T src_data_size, ID3DX11ThreadPump *pump, D3DX11_IMAGE_INFO *img_info, HRESULT *hresult); +HRESULT WINAPI D3DX11SaveTextureToFileA(ID3D11DeviceContext *context, ID3D11Resource *texture, + D3DX11_IMAGE_FILE_FORMAT format, const char *dst_filename); + +HRESULT WINAPI D3DX11SaveTextureToFileW(ID3D11DeviceContext *context, ID3D11Resource *texture, + D3DX11_IMAGE_FILE_FORMAT format, const WCHAR *dst_filename); + HRESULT WINAPI D3DX11SaveTextureToMemory(ID3D11DeviceContext *context, ID3D11Resource *texture, D3DX11_IMAGE_FILE_FORMAT format, ID3D10Blob **buffer, UINT flags); -- 2.17.1

2 1

[PATCH] winex11.drv: Use the ARRAY_SIZE() macro
by Michael Stefaniuc 19 Sep '18

19 Sep '18

Signed-off-by: Michael Stefaniuc <mstefani(a)winehq.org> --- dlls/winex11.drv/brush.c | 2 +- dlls/winex11.drv/clipboard.c | 4 ++-- dlls/winex11.drv/event.c | 2 +- dlls/winex11.drv/graphics.c | 6 +++--- dlls/winex11.drv/mouse.c | 6 +++--- dlls/winex11.drv/opengl.c | 2 +- dlls/winex11.drv/pen.c | 10 +++++----- dlls/winex11.drv/systray.c | 6 +++--- dlls/winex11.drv/window.c | 2 +- 9 files changed, 20 insertions(+), 20 deletions(-) diff --git a/dlls/winex11.drv/brush.c b/dlls/winex11.drv/brush.c index 46bd2dd814..e3e5668b5a 100644 --- a/dlls/winex11.drv/brush.c +++ b/dlls/winex11.drv/brush.c @@ -169,7 +169,7 @@ static Pixmap BRUSH_DitherMono( COLORREF color ) { 0x1, 0x3 }, /* LTGRAY */ }; int gray = (30 * GetRValue(color) + 59 * GetGValue(color) + 11 * GetBValue(color)) / 100; - int idx = gray * (sizeof gray_dither/sizeof gray_dither[0] + 1)/256 - 1; + int idx = gray * (ARRAY_SIZE( gray_dither ) + 1)/256 - 1; TRACE("color=%06x -> gray=%x\n", color, gray); return XCreateBitmapFromData( gdi_display, root_window, gray_dither[idx], 2, 2 ); diff --git a/dlls/winex11.drv/clipboard.c b/dlls/winex11.drv/clipboard.c index 296c00c3a5..a37530fdbf 100644 --- a/dlls/winex11.drv/clipboard.c +++ b/dlls/winex11.drv/clipboard.c @@ -1933,12 +1933,12 @@ static LRESULT CALLBACK clipboard_wndproc( HWND hwnd, UINT msg, WPARAM wp, LPARA static BOOL wait_clipboard_mutex(void) { static const WCHAR prefix[] = {'_','_','w','i','n','e','_','c','l','i','p','b','o','a','r','d','_'}; - WCHAR buffer[MAX_PATH + sizeof(prefix) / sizeof(WCHAR)]; + WCHAR buffer[MAX_PATH + ARRAY_SIZE( prefix )]; HANDLE mutex; memcpy( buffer, prefix, sizeof(prefix) ); if (!GetUserObjectInformationW( GetProcessWindowStation(), UOI_NAME, - buffer + sizeof(prefix) / sizeof(WCHAR), + buffer + ARRAY_SIZE( prefix ), sizeof(buffer) - sizeof(prefix), NULL )) { ERR( "failed to get winstation name\n" ); diff --git a/dlls/winex11.drv/event.c b/dlls/winex11.drv/event.c index b36ce6f267..6054f645c4 100644 --- a/dlls/winex11.drv/event.c +++ b/dlls/winex11.drv/event.c @@ -1739,7 +1739,7 @@ static BOOL X11DRV_ClientMessage( HWND hwnd, XEvent *xev ) return FALSE; } - for (i = 0; i < sizeof(client_messages)/sizeof(client_messages[0]); i++) + for (i = 0; i < ARRAY_SIZE( client_messages ); i++) { if (event->message_type == X11DRV_Atoms[client_messages[i].atom - FIRST_XATOM]) { diff --git a/dlls/winex11.drv/graphics.c b/dlls/winex11.drv/graphics.c index e8c59f9baf..2209053617 100644 --- a/dlls/winex11.drv/graphics.c +++ b/dlls/winex11.drv/graphics.c @@ -1644,7 +1644,7 @@ BOOL X11DRV_GetICMProfile( PHYSDEV dev, LPDWORD size, LPWSTR filename ) 'P','r','o','f','i','l','e','.','i','c','m',0}; HKEY hkey; DWORD required, len; - WCHAR profile[MAX_PATH], fullname[2*MAX_PATH + sizeof(color_path)/sizeof(WCHAR)]; + WCHAR profile[MAX_PATH], fullname[2*MAX_PATH + ARRAY_SIZE( color_path )]; unsigned char *buffer; unsigned long buflen; @@ -1653,7 +1653,7 @@ BOOL X11DRV_GetICMProfile( PHYSDEV dev, LPDWORD size, LPWSTR filename ) GetSystemDirectoryW( fullname, MAX_PATH ); strcatW( fullname, color_path ); - len = sizeof(profile)/sizeof(WCHAR); + len = ARRAY_SIZE( profile ); if (!RegCreateKeyExW( HKEY_LOCAL_MACHINE, mntr_key, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, NULL ) && !RegEnumValueW( hkey, 0, profile, &len, NULL, NULL, NULL, NULL )) /* FIXME handle multiple values */ { @@ -1726,7 +1726,7 @@ INT X11DRV_EnumICMProfiles( PHYSDEV dev, ICMENUMPROCW proc, LPARAM lparam ) return -1; len_sysdir = GetSystemDirectoryW( sysdir, MAX_PATH ); - len_path = len_sysdir + sizeof(color_path) / sizeof(color_path[0]) - 1; + len_path = len_sysdir + ARRAY_SIZE( color_path ) - 1; len = 64; for (;;) { diff --git a/dlls/winex11.drv/mouse.c b/dlls/winex11.drv/mouse.c index 10985c1472..d6787068a9 100644 --- a/dlls/winex11.drv/mouse.c +++ b/dlls/winex11.drv/mouse.c @@ -986,7 +986,7 @@ static int find_fallback_shape( const char *name ) { struct cursor_font_fallback *fallback; - if ((fallback = bsearch( name, fallbacks, sizeof(fallbacks) / sizeof(fallbacks[0]), + if ((fallback = bsearch( name, fallbacks, ARRAY_SIZE( fallbacks ), sizeof(*fallback), fallback_cmp ))) return fallback->shape; return -1; @@ -1038,9 +1038,9 @@ static Cursor create_xcursor_system_cursor( const ICONINFOEXW *info ) if (info->szResName[0]) goto done; /* only integer resources are supported here */ if (!(module = GetModuleHandleW( info->szModName ))) goto done; - for (i = 0; i < sizeof(module_cursors)/sizeof(module_cursors[0]); i++) + for (i = 0; i < ARRAY_SIZE( module_cursors ); i++) if (GetModuleHandleW( module_cursors[i].name ) == module) break; - if (i == sizeof(module_cursors)/sizeof(module_cursors[0])) goto done; + if (i == ARRAY_SIZE( module_cursors )) goto done; cursors = module_cursors[i].cursors; for (i = 0; cursors[i].id; i++) diff --git a/dlls/winex11.drv/opengl.c b/dlls/winex11.drv/opengl.c index 0b0fd5179a..13a1da32ea 100644 --- a/dlls/winex11.drv/opengl.c +++ b/dlls/winex11.drv/opengl.c @@ -555,7 +555,7 @@ static BOOL WINAPI init_opengl( INIT_ONCE *once, void *param, void **context ) return TRUE; } - for (i = 0; i < sizeof(opengl_func_names)/sizeof(opengl_func_names[0]); i++) + for (i = 0; i < ARRAY_SIZE( opengl_func_names ); i++) { if (!(((void **)&opengl_funcs.gl)[i] = wine_dlsym( opengl_handle, opengl_func_names[i], NULL, 0 ))) { diff --git a/dlls/winex11.drv/pen.c b/dlls/winex11.drv/pen.c index c6a15daabf..6df26597b9 100644 --- a/dlls/winex11.drv/pen.c +++ b/dlls/winex11.drv/pen.c @@ -108,27 +108,27 @@ HPEN X11DRV_SelectPen( PHYSDEV dev, HPEN hpen, const struct brush_pattern *patte switch(logpen.lopnStyle & PS_STYLE_MASK) { case PS_DASH: - physDev->pen.dash_len = sizeof(PEN_dash)/sizeof(*PEN_dash); + physDev->pen.dash_len = ARRAY_SIZE( PEN_dash ); memcpy(physDev->pen.dashes, physDev->pen.ext ? EXTPEN_dash : PEN_dash, physDev->pen.dash_len); break; case PS_DOT: - physDev->pen.dash_len = sizeof(PEN_dot)/sizeof(*PEN_dot); + physDev->pen.dash_len = ARRAY_SIZE( PEN_dot ); memcpy(physDev->pen.dashes, physDev->pen.ext ? EXTPEN_dot : PEN_dot, physDev->pen.dash_len); break; case PS_DASHDOT: - physDev->pen.dash_len = sizeof(PEN_dashdot)/sizeof(*PEN_dashdot); + physDev->pen.dash_len = ARRAY_SIZE( PEN_dashdot ); memcpy(physDev->pen.dashes, physDev->pen.ext ? EXTPEN_dashdot : PEN_dashdot, physDev->pen.dash_len); break; case PS_DASHDOTDOT: - physDev->pen.dash_len = sizeof(PEN_dashdotdot)/sizeof(*PEN_dashdotdot); + physDev->pen.dash_len = ARRAY_SIZE( PEN_dashdotdot ); memcpy(physDev->pen.dashes, physDev->pen.ext ? EXTPEN_dashdotdot : PEN_dashdotdot, physDev->pen.dash_len); break; case PS_ALTERNATE: - physDev->pen.dash_len = sizeof(PEN_alternate)/sizeof(*PEN_alternate); + physDev->pen.dash_len = ARRAY_SIZE( PEN_alternate ); memcpy(physDev->pen.dashes, PEN_alternate, physDev->pen.dash_len); break; case PS_USERSTYLE: diff --git a/dlls/winex11.drv/systray.c b/dlls/winex11.drv/systray.c index da322e0436..d4262c43cf 100644 --- a/dlls/winex11.drv/systray.c +++ b/dlls/winex11.drv/systray.c @@ -772,13 +772,13 @@ static BOOL modify_icon( struct tray_icon *icon, NOTIFYICONDATAW *nid ) } if (nid->uFlags & NIF_TIP) { - lstrcpynW(icon->tiptext, nid->szTip, sizeof(icon->tiptext)/sizeof(WCHAR)); + lstrcpynW(icon->tiptext, nid->szTip, ARRAY_SIZE( icon->tiptext )); if (icon->tooltip) update_tooltip_text(icon); } if (nid->uFlags & NIF_INFO && nid->cbSize >= NOTIFYICONDATAA_V2_SIZE) { - lstrcpynW( icon->info_text, nid->szInfo, sizeof(icon->info_text)/sizeof(WCHAR) ); - lstrcpynW( icon->info_title, nid->szInfoTitle, sizeof(icon->info_title)/sizeof(WCHAR) ); + lstrcpynW( icon->info_text, nid->szInfo, ARRAY_SIZE( icon->info_text )); + lstrcpynW( icon->info_title, nid->szInfoTitle, ARRAY_SIZE( icon->info_title )); icon->info_flags = nid->dwInfoFlags; icon->info_timeout = max(min(nid->u.uTimeout, BALLOON_SHOW_MAX_TIMEOUT), BALLOON_SHOW_MIN_TIMEOUT); icon->info_icon = nid->hBalloonIcon; diff --git a/dlls/winex11.drv/window.c b/dlls/winex11.drv/window.c index 0a4f118c34..7a3b340e19 100644 --- a/dlls/winex11.drv/window.c +++ b/dlls/winex11.drv/window.c @@ -1530,7 +1530,7 @@ static void create_whole_window( struct x11drv_win_data *data ) SetPropA( data->hwnd, whole_window_prop, (HANDLE)data->whole_window ); /* set the window text */ - if (!InternalGetWindowText( data->hwnd, text, sizeof(text)/sizeof(WCHAR) )) text[0] = 0; + if (!InternalGetWindowText( data->hwnd, text, ARRAY_SIZE( text ))) text[0] = 0; sync_window_text( data->display, data->whole_window, text ); /* set the window region */ -- 2.14.4

1 0

[PATCH 3/3] dxgi/tests: Avoid "skipping tests" in skip() messages.
by Józef Kucia 19 Sep '18

19 Sep '18

skip() prints "Tests skipped:". Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/dxgi/tests/dxgi.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/dlls/dxgi/tests/dxgi.c b/dlls/dxgi/tests/dxgi.c index 62070e0bcf20..d1908ac1c2b8 100644 --- a/dlls/dxgi/tests/dxgi.c +++ b/dlls/dxgi/tests/dxgi.c @@ -643,7 +643,7 @@ static void test_adapter_desc(void) if (!(device = create_device(0))) { - skip("Failed to create device, skipping tests.\n"); + skip("Failed to create device.\n"); return; } @@ -884,7 +884,7 @@ static void test_create_surface(void) if (!(device = create_device(0))) { - skip("Failed to create device, skipping tests.\n"); + skip("Failed to create device.\n"); return; } @@ -922,7 +922,7 @@ static void test_parents(void) if (!(device = create_device(0))) { - skip("Failed to create device, skipping tests.\n"); + skip("Failed to create device.\n"); return; } @@ -947,7 +947,7 @@ static void test_parents(void) hr = IDXGIAdapter_EnumOutputs(adapter, 0, &output); if (hr == DXGI_ERROR_NOT_FOUND) { - skip("Adapter has not outputs, skipping output tests.\n"); + skip("Adapter has not outputs.\n"); } else { @@ -990,7 +990,7 @@ static void test_output(void) if (!(device = create_device(0))) { - skip("Failed to create device, skipping tests.\n"); + skip("Failed to create device.\n"); return; } @@ -1000,7 +1000,7 @@ static void test_output(void) hr = IDXGIAdapter_EnumOutputs(adapter, 0, &output); if (hr == DXGI_ERROR_NOT_FOUND) { - skip("Adapter doesn't have any outputs, skipping tests.\n"); + skip("Adapter doesn't have any outputs.\n"); IDXGIAdapter_Release(adapter); IDXGIDevice_Release(device); return; @@ -1076,7 +1076,7 @@ static void test_output(void) } else { - skip("Not enough modes for test, skipping.\n"); + skip("Not enough modes for test.\n"); } heap_free(modes); @@ -1308,7 +1308,7 @@ static void test_create_swapchain(void) if (!(device = create_device(0))) { - skip("Failed to create device, skipping tests.\n"); + skip("Failed to create device.\n"); return; } @@ -2916,7 +2916,7 @@ static void test_private_data(void) if (!(device = create_device(0))) { - skip("Failed to create device, skipping tests.\n"); + skip("Failed to create device.\n"); return; } @@ -3489,7 +3489,7 @@ static void test_swapchain_parameters(void) if (!(device = create_device(0))) { - skip("Failed to create device, skipping tests.\n"); + skip("Failed to create device.\n"); return; } window = CreateWindowA("static", "dxgi_test", WS_OVERLAPPEDWINDOW | WS_VISIBLE, -- 2.16.4

2 1

[PATCH 2/3] dxgi/tests: Add test for swapchain window styles.
by Józef Kucia 19 Sep '18

19 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/dxgi/tests/dxgi.c | 140 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 140 insertions(+) diff --git a/dlls/dxgi/tests/dxgi.c b/dlls/dxgi/tests/dxgi.c index 8c41eab41cfe..62070e0bcf20 100644 --- a/dlls/dxgi/tests/dxgi.c +++ b/dlls/dxgi/tests/dxgi.c @@ -4480,6 +4480,145 @@ done: UnregisterClassA("dxgi_test_wndproc_wc", GetModuleHandleA(NULL)); } +static void test_swapchain_window_styles(void) +{ + LONG style, exstyle, fullscreen_style, fullscreen_exstyle; + DXGI_SWAP_CHAIN_DESC swapchain_desc; + IDXGISwapChain *swapchain; + IDXGIFactory *factory; + IDXGIAdapter *adapter; + IDXGIDevice *device; + ULONG refcount; + unsigned int i; + HRESULT hr; + + static const struct + { + LONG style, exstyle; + LONG expected_style, expected_exstyle; + } + tests[] = + { + {WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX, 0, + WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_CLIPSIBLINGS, + WS_EX_WINDOWEDGE}, + {WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_VISIBLE, 0, + WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_CLIPSIBLINGS | WS_VISIBLE, + WS_EX_WINDOWEDGE}, + {WS_OVERLAPPED | WS_VISIBLE, 0, + WS_OVERLAPPED | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CAPTION, WS_EX_WINDOWEDGE}, + {WS_CAPTION | WS_DISABLED, WS_EX_TOPMOST, + WS_CAPTION | WS_DISABLED | WS_CLIPSIBLINGS, WS_EX_TOPMOST | WS_EX_WINDOWEDGE}, + {WS_CAPTION | WS_DISABLED | WS_VISIBLE, WS_EX_TOPMOST, + WS_CAPTION | WS_DISABLED | WS_VISIBLE | WS_CLIPSIBLINGS, WS_EX_TOPMOST | WS_EX_WINDOWEDGE}, + {WS_CAPTION | WS_SYSMENU | WS_VISIBLE, WS_EX_APPWINDOW, + WS_CAPTION | WS_SYSMENU | WS_VISIBLE | WS_CLIPSIBLINGS, WS_EX_APPWINDOW | WS_EX_WINDOWEDGE}, + }; + + if (!(device = create_device(0))) + { + skip("Failed to create device.\n"); + return; + } + + hr = IDXGIDevice_GetAdapter(device, &adapter); + ok(hr == S_OK, "Failed to get adapter, hr %#x.\n", hr); + hr = IDXGIAdapter_GetParent(adapter, &IID_IDXGIFactory, (void **)&factory); + ok(hr == S_OK, "Failed to get parent, hr %#x.\n", hr); + IDXGIAdapter_Release(adapter); + + swapchain_desc.BufferDesc.Width = 800; + swapchain_desc.BufferDesc.Height = 600; + swapchain_desc.BufferDesc.RefreshRate.Numerator = 60; + swapchain_desc.BufferDesc.RefreshRate.Denominator = 60; + swapchain_desc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + swapchain_desc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; + swapchain_desc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; + swapchain_desc.SampleDesc.Count = 1; + swapchain_desc.SampleDesc.Quality = 0; + swapchain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + swapchain_desc.BufferCount = 1; + swapchain_desc.Windowed = TRUE; + swapchain_desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; + swapchain_desc.Flags = 0; + + for (i = 0; i < ARRAY_SIZE(tests); ++i) + { + swapchain_desc.OutputWindow = CreateWindowExA(tests[i].exstyle, "static", "dxgi_test", + tests[i].style, 0, 0, 400, 200, 0, 0, 0, 0); + + style = GetWindowLongA(swapchain_desc.OutputWindow, GWL_STYLE); + exstyle = GetWindowLongA(swapchain_desc.OutputWindow, GWL_EXSTYLE); + ok(style == tests[i].expected_style, "Test %u: Got style %#x, expected %#x.\n", + i, style, tests[i].expected_style); + ok(exstyle == tests[i].expected_exstyle, "Test %u: Got exstyle %#x, expected %#x.\n", + i, exstyle, tests[i].expected_exstyle); + + fullscreen_style = tests[i].expected_style & (WS_VISIBLE | WS_DISABLED | WS_CLIPSIBLINGS); + fullscreen_exstyle = (tests[i].expected_exstyle & WS_EX_APPWINDOW) | WS_EX_TOPMOST; + + hr = IDXGIFactory_CreateSwapChain(factory, (IUnknown *)device, &swapchain_desc, &swapchain); + ok(hr == S_OK, "Failed to create swapchain, hr %#x.\n", hr); + + style = GetWindowLongA(swapchain_desc.OutputWindow, GWL_STYLE); + exstyle = GetWindowLongA(swapchain_desc.OutputWindow, GWL_EXSTYLE); + ok(style == tests[i].expected_style, "Test %u: Got style %#x, expected %#x.\n", + i, style, tests[i].expected_style); + ok(exstyle == tests[i].expected_exstyle, "Test %u: Got exstyle %#x, expected %#x.\n", + i, exstyle, tests[i].expected_exstyle); + + hr = IDXGISwapChain_SetFullscreenState(swapchain, TRUE, NULL); + ok(hr == S_OK || hr == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE + || broken(hr == DXGI_ERROR_UNSUPPORTED), /* Win 7 testbot */ + "Failed to set fullscreen state, hr %#x.\n", hr); + if (SUCCEEDED(hr)) + { + style = GetWindowLongA(swapchain_desc.OutputWindow, GWL_STYLE); + exstyle = GetWindowLongA(swapchain_desc.OutputWindow, GWL_EXSTYLE); + todo_wine + ok(style == fullscreen_style, "Test %u: Got style %#x, expected %#x.\n", + i, style, fullscreen_style); + ok(exstyle == fullscreen_exstyle, "Test %u: Got exstyle %#x, expected %#x.\n", + i, exstyle, fullscreen_exstyle); + + hr = IDXGISwapChain_SetFullscreenState(swapchain, FALSE, NULL); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + } + else + { + skip("Test %u: Could not change fullscreen state.\n", i); + } + + style = GetWindowLongA(swapchain_desc.OutputWindow, GWL_STYLE); + exstyle = GetWindowLongA(swapchain_desc.OutputWindow, GWL_EXSTYLE); + todo_wine_if(!(tests[i].expected_style & WS_VISIBLE)) + ok(style == tests[i].expected_style, "Test %u: Got style %#x, expected %#x.\n", + i, style, tests[i].expected_style); + todo_wine_if(!(tests[i].expected_exstyle & WS_EX_TOPMOST)) + ok(exstyle == tests[i].expected_exstyle, "Test %u: Got exstyle %#x, expected %#x.\n", + i, exstyle, tests[i].expected_exstyle); + + refcount = IDXGISwapChain_Release(swapchain); + ok(!refcount, "IDXGISwapChain has %u references left.\n", refcount); + + style = GetWindowLongA(swapchain_desc.OutputWindow, GWL_STYLE); + exstyle = GetWindowLongA(swapchain_desc.OutputWindow, GWL_EXSTYLE); + todo_wine_if(!(tests[i].expected_style & WS_VISIBLE)) + ok(style == tests[i].expected_style, "Test %u: Got style %#x, expected %#x.\n", + i, style, tests[i].expected_style); + todo_wine_if(!(tests[i].expected_exstyle & WS_EX_TOPMOST)) + ok(exstyle == tests[i].expected_exstyle, "Test %u: Got exstyle %#x, expected %#x.\n", + i, exstyle, tests[i].expected_exstyle); + + DestroyWindow(swapchain_desc.OutputWindow); + } + + refcount = IDXGIDevice_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); + refcount = IDXGIFactory_Release(factory); + ok(!refcount, "Factory has %u references left.\n", refcount); +} + static void run_on_d3d10(void (*test_func)(IUnknown *device, BOOL is_d3d12)) { IDXGIDevice *device; @@ -4574,6 +4713,7 @@ START_TEST(dxgi) test_inexact_modes(); test_swapchain_parameters(); test_swapchain_window_messages(); + test_swapchain_window_styles(); run_on_d3d10(test_swapchain_resize); run_on_d3d10(test_swapchain_backbuffer_index); run_on_d3d10(test_swapchain_formats); -- 2.16.4

3 2

[PATCH 1/3] dxgi/tests: Add test for swapchain window messages.
by Józef Kucia 19 Sep '18

19 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- With some tweaks wined3d passes the test. --- dlls/dxgi/tests/dxgi.c | 276 ++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 273 insertions(+), 3 deletions(-) diff --git a/dlls/dxgi/tests/dxgi.c b/dlls/dxgi/tests/dxgi.c index 9ab247254922..8c41eab41cfe 100644 --- a/dlls/dxgi/tests/dxgi.c +++ b/dlls/dxgi/tests/dxgi.c @@ -2152,9 +2152,9 @@ static void test_set_fullscreen(void) ok(SUCCEEDED(hr), "CreateSwapChain failed, hr %#x.\n", hr); check_swapchain_fullscreen_state(swapchain, &initial_state); hr = IDXGISwapChain_SetFullscreenState(swapchain, TRUE, NULL); - ok(SUCCEEDED(hr) || hr == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE || - broken(hr == DXGI_ERROR_UNSUPPORTED), /* Win 7 testbot */ - "SetFullscreenState failed, hr %#x.\n", hr); + ok(SUCCEEDED(hr) || hr == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE + || broken(hr == DXGI_ERROR_UNSUPPORTED), /* Win 7 testbot */ + "SetFullscreenState failed, hr %#x.\n", hr); if (FAILED(hr)) { skip("Could not change fullscreen state.\n"); @@ -4211,6 +4211,275 @@ static void test_object_wrapping(void) ok(!refcount, "Factory has %u references left.\n", refcount); } +/* try to make sure pending X events have been processed before continuing */ +static void flush_events(void) +{ + int diff = 200; + DWORD time; + MSG msg; + + time = GetTickCount() + diff; + while (diff > 0) + { + if (MsgWaitForMultipleObjects(0, NULL, FALSE, 100, QS_ALLINPUT) == WAIT_TIMEOUT) + break; + while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) + DispatchMessageA(&msg); + diff = time - GetTickCount(); + } +} + +struct message +{ + unsigned int message; + BOOL check_wparam; + WPARAM expect_wparam; +}; + +static BOOL expect_no_messages; +static const struct message *expect_messages; +static const struct message *expect_messages_broken; + +static BOOL check_message(const struct message *expected, + HWND hwnd, unsigned int message, WPARAM wparam, LPARAM lparam) +{ + if (expected->message != message) + return FALSE; + + if (expected->check_wparam) + { + ok(wparam == expected->expect_wparam, + "Got unexpected wparam %lx for message %x, expected %lx.\n", + wparam, message, expected->expect_wparam); + } + + return TRUE; +} + +static LRESULT CALLBACK test_wndproc(HWND hwnd, unsigned int message, WPARAM wparam, LPARAM lparam) +{ + ok(!expect_no_messages, "Got unexpected message %#x, hwnd %p, wparam %#lx, lparam %#lx.\n", + message, hwnd, wparam, lparam); + + if (expect_messages) + { + if (check_message(expect_messages, hwnd, message, wparam, lparam)) + ++expect_messages; + } + + if (expect_messages_broken) + { + if (check_message(expect_messages_broken, hwnd, message, wparam, lparam)) + ++expect_messages_broken; + } + + return DefWindowProcA(hwnd, message, wparam, lparam); +} + +static void test_swapchain_window_messages(void) +{ + DXGI_SWAP_CHAIN_DESC swapchain_desc; + IDXGISwapChain *swapchain; + DXGI_MODE_DESC mode_desc; + IDXGIFactory *factory; + IDXGIAdapter *adapter; + IDXGIDevice *device; + ULONG refcount; + WNDCLASSA wc; + HWND window; + HRESULT hr; + + static const struct message enter_fullscreen_messages[] = + { + {WM_STYLECHANGING, TRUE, GWL_STYLE}, + {WM_STYLECHANGED, TRUE, GWL_STYLE}, + {WM_STYLECHANGING, TRUE, GWL_EXSTYLE}, + {WM_STYLECHANGED, TRUE, GWL_EXSTYLE}, + {WM_WINDOWPOSCHANGING, FALSE, 0}, + {WM_GETMINMAXINFO, FALSE, 0}, + {WM_NCCALCSIZE, FALSE, 0}, + {WM_WINDOWPOSCHANGED, FALSE, 0}, + {WM_MOVE, FALSE, 0}, + {WM_SIZE, FALSE, 0}, + {0, FALSE, 0}, + }; + static const struct message enter_fullscreen_messages_vista[] = + { + {WM_STYLECHANGING, TRUE, GWL_STYLE}, + {WM_STYLECHANGED, TRUE, GWL_STYLE}, + {WM_WINDOWPOSCHANGING, FALSE, 0}, + {WM_NCCALCSIZE, FALSE, 0}, + {WM_WINDOWPOSCHANGED, FALSE, 0}, + {WM_MOVE, FALSE, 0}, + {WM_SIZE, FALSE, 0}, + {WM_STYLECHANGING, TRUE, GWL_EXSTYLE}, + {WM_STYLECHANGED, TRUE, GWL_EXSTYLE}, + {WM_WINDOWPOSCHANGING, FALSE, 0}, + {WM_GETMINMAXINFO, FALSE, 0}, + {WM_NCCALCSIZE, FALSE, 0}, + {WM_WINDOWPOSCHANGED, FALSE, 0}, + {WM_SIZE, FALSE, 0}, + {0, FALSE, 0}, + }; + static const struct message leave_fullscreen_messages[] = + { + {WM_STYLECHANGING, TRUE, GWL_STYLE}, + {WM_STYLECHANGED, TRUE, GWL_STYLE}, + {WM_STYLECHANGING, TRUE, GWL_EXSTYLE}, + {WM_STYLECHANGED, TRUE, GWL_EXSTYLE}, + {WM_WINDOWPOSCHANGING, FALSE, 0}, + {WM_GETMINMAXINFO, FALSE, 0}, + {WM_NCCALCSIZE, FALSE, 0}, + {WM_WINDOWPOSCHANGED, FALSE, 0}, + {WM_MOVE, FALSE, 0}, + {WM_SIZE, FALSE, 0}, + {0, FALSE, 0}, + }; + static const struct message resize_target_messages[] = + { + {WM_WINDOWPOSCHANGING, FALSE, 0}, + {WM_GETMINMAXINFO, FALSE, 0}, + {WM_NCCALCSIZE, FALSE, 0}, + {WM_WINDOWPOSCHANGED, FALSE, 0}, + {WM_SIZE, FALSE, 0}, + {0, FALSE, 0}, + }; + + if (!(device = create_device(0))) + { + skip("Failed to create device.\n"); + return; + } + + memset(&wc, 0, sizeof(wc)); + wc.lpfnWndProc = test_wndproc; + wc.lpszClassName = "dxgi_test_wndproc_wc"; + ok(RegisterClassA(&wc), "Failed to register window class.\n"); + window = CreateWindowA("dxgi_test_wndproc_wc", "dxgi_test", 0, 0, 0, 400, 200, 0, 0, 0, 0); + ok(!!window, "Failed to create window.\n"); + + hr = IDXGIDevice_GetAdapter(device, &adapter); + ok(hr == S_OK, "Failed to get adapter, hr %#x.\n", hr); + hr = IDXGIAdapter_GetParent(adapter, &IID_IDXGIFactory, (void **)&factory); + ok(hr == S_OK, "Failed to get parent, hr %#x.\n", hr); + IDXGIAdapter_Release(adapter); + + swapchain_desc.BufferDesc.Width = 800; + swapchain_desc.BufferDesc.Height = 600; + swapchain_desc.BufferDesc.RefreshRate.Numerator = 60; + swapchain_desc.BufferDesc.RefreshRate.Denominator = 60; + swapchain_desc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + swapchain_desc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; + swapchain_desc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; + swapchain_desc.SampleDesc.Count = 1; + swapchain_desc.SampleDesc.Quality = 0; + swapchain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + swapchain_desc.BufferCount = 1; + swapchain_desc.OutputWindow = window; + swapchain_desc.Windowed = TRUE; + swapchain_desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; + swapchain_desc.Flags = 0; + + /* create swapchain */ + flush_events(); + expect_no_messages = TRUE; + hr = IDXGIFactory_CreateSwapChain(factory, (IUnknown *)device, &swapchain_desc, &swapchain); + ok(hr == S_OK, "Failed to create swapchain, hr %#x.\n", hr); + flush_events(); + expect_no_messages = FALSE; + + /* resize target */ + expect_messages = resize_target_messages; + memset(&mode_desc, 0, sizeof(mode_desc)); + mode_desc.Width = 800; + mode_desc.Width = 600; + hr = IDXGISwapChain_ResizeTarget(swapchain, &mode_desc); + ok(hr == S_OK, "Failed to resize target, hr %#x.\n", hr); + flush_events(); + ok(!expect_messages->message, "Expected message %#x.\n", expect_messages->message); + + expect_messages = resize_target_messages; + memset(&mode_desc, 0, sizeof(mode_desc)); + mode_desc.Width = 400; + mode_desc.Width = 200; + hr = IDXGISwapChain_ResizeTarget(swapchain, &mode_desc); + ok(hr == S_OK, "Failed to resize target, hr %#x.\n", hr); + flush_events(); + ok(!expect_messages->message, "Expected message %#x.\n", expect_messages->message); + + /* enter fullscreen */ + expect_messages = enter_fullscreen_messages; + expect_messages_broken = enter_fullscreen_messages_vista; + hr = IDXGISwapChain_SetFullscreenState(swapchain, TRUE, NULL); + ok(hr == S_OK || hr == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE + || broken(hr == DXGI_ERROR_UNSUPPORTED), /* Win 7 testbot */ + "Failed to enter fullscreen, hr %#x.\n", hr); + if (FAILED(hr)) + { + skip("Could not change fullscreen state.\n"); + goto done; + } + flush_events(); + todo_wine + ok(!expect_messages->message || broken(!expect_messages_broken->message), + "Expected message %#x or %#x.\n", + expect_messages->message, expect_messages_broken->message); + expect_messages_broken = NULL; + + /* leave fullscreen */ + expect_messages = leave_fullscreen_messages; + hr = IDXGISwapChain_SetFullscreenState(swapchain, FALSE, NULL); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + flush_events(); + todo_wine + ok(!expect_messages->message, "Expected message %#x.\n", expect_messages->message); + expect_messages = NULL; + + refcount = IDXGISwapChain_Release(swapchain); + ok(!refcount, "IDXGISwapChain has %u references left.\n", refcount); + + /* create fullscreen swapchain */ + DestroyWindow(window); + window = CreateWindowA("dxgi_test_wndproc_wc", "dxgi_test", 0, 0, 0, 400, 200, 0, 0, 0, 0); + ok(!!window, "Failed to create window.\n"); + swapchain_desc.OutputWindow = window; + swapchain_desc.Windowed = FALSE; + swapchain_desc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; + flush_events(); + + expect_messages = enter_fullscreen_messages; + expect_messages_broken = enter_fullscreen_messages_vista; + hr = IDXGIFactory_CreateSwapChain(factory, (IUnknown *)device, &swapchain_desc, &swapchain); + ok(hr == S_OK, "Failed to create swapchain, hr %#x.\n", hr); + flush_events(); + todo_wine + ok(!expect_messages->message || broken(!expect_messages_broken->message), + "Expected message %#x or %#x.\n", + expect_messages->message, expect_messages_broken->message); + expect_messages_broken = NULL; + + /* leave fullscreen */ + expect_messages = leave_fullscreen_messages; + hr = IDXGISwapChain_SetFullscreenState(swapchain, FALSE, NULL); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + flush_events(); + todo_wine + ok(!expect_messages->message, "Expected message %#x.\n", expect_messages->message); + expect_messages = NULL; + +done: + refcount = IDXGISwapChain_Release(swapchain); + ok(!refcount, "IDXGISwapChain has %u references left.\n", refcount); + DestroyWindow(window); + + refcount = IDXGIDevice_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); + refcount = IDXGIFactory_Release(factory); + ok(!refcount, "Factory has %u references left.\n", refcount); + + UnregisterClassA("dxgi_test_wndproc_wc", GetModuleHandleA(NULL)); +} + static void run_on_d3d10(void (*test_func)(IUnknown *device, BOOL is_d3d12)) { IDXGIDevice *device; @@ -4304,6 +4573,7 @@ START_TEST(dxgi) test_resize_target(); test_inexact_modes(); test_swapchain_parameters(); + test_swapchain_window_messages(); run_on_d3d10(test_swapchain_resize); run_on_d3d10(test_swapchain_backbuffer_index); run_on_d3d10(test_swapchain_formats); -- 2.16.4

2 1

[PATCH] comctl32: Add NULL checks to SetWindowSubclass (Valgrind)
by Sven Baars 19 Sep '18

19 Sep '18

Signed-off-by: Sven Baars <sven.wine(a)gmail.com> --- Without these checks I found memory leaks in for instance updown.c dlls/comctl32/commctrl.c | 3 +++ dlls/comctl32/tests/subclass.c | 31 +++++++++++++++++++++++-------- 2 files changed, 26 insertions(+), 8 deletions(-) diff --git a/dlls/comctl32/commctrl.c b/dlls/comctl32/commctrl.c index 45b93bdc8b..c228b647f8 100644 --- a/dlls/comctl32/commctrl.c +++ b/dlls/comctl32/commctrl.c @@ -1082,6 +1082,9 @@ BOOL WINAPI SetWindowSubclass (HWND hWnd, SUBCLASSPROC pfnSubclass, TRACE ("(%p, %p, %lx, %lx)\n", hWnd, pfnSubclass, uIDSubclass, dwRef); + if (!hWnd || !pfnSubclass) + return FALSE; + /* Since the window procedure that we set here has two additional arguments, * we can't simply set it as the new window procedure of the window. So we * set our own window procedure and then calculate the other two arguments diff --git a/dlls/comctl32/tests/subclass.c b/dlls/comctl32/tests/subclass.c index 75a134352e..41ba06560a 100644 --- a/dlls/comctl32/tests/subclass.c +++ b/dlls/comctl32/tests/subclass.c @@ -218,46 +218,61 @@ static LRESULT WINAPI wnd_proc_sub(HWND hwnd, UINT message, WPARAM wParam, LPARA static void test_subclass(void) { + BOOL ret; HWND hwnd = CreateWindowExA(0, "TestSubclass", "Test subclass", WS_OVERLAPPEDWINDOW, 100, 100, 200, 200, 0, 0, 0, NULL); ok(hwnd != NULL, "failed to create test subclass wnd\n"); - pSetWindowSubclass(hwnd, wnd_proc_sub, 2, 0); + ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 2, 0); + ok(ret == TRUE, "Expected TRUE\n"); SendMessageA(hwnd, WM_USER, 1, 0); SendMessageA(hwnd, WM_USER, 2, 0); ok_sequence(Sub_BasicTest, "Basic"); - pSetWindowSubclass(hwnd, wnd_proc_sub, 2, DELETE_SELF); + ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 2, DELETE_SELF); + ok(ret == TRUE, "Expected TRUE\n"); SendMessageA(hwnd, WM_USER, 1, 1); ok_sequence(Sub_DeletedTest, "Deleted"); SendMessageA(hwnd, WM_USER, 1, 0); ok_sequence(Sub_AfterDeletedTest, "After Deleted"); - pSetWindowSubclass(hwnd, wnd_proc_sub, 2, 0); + ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 2, 0); + ok(ret == TRUE, "Expected TRUE\n"); orig_proc_3 = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)wnd_proc_3); SendMessageA(hwnd, WM_USER, 1, 0); SendMessageA(hwnd, WM_USER, 2, 0); ok_sequence(Sub_OldAfterNewTest, "Old after New"); - pSetWindowSubclass(hwnd, wnd_proc_sub, 4, 0); + ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 4, 0); + ok(ret == TRUE, "Expected TRUE\n"); SendMessageA(hwnd, WM_USER, 1, 0); ok_sequence(Sub_MixTest, "Mix"); /* Now the fun starts */ - pSetWindowSubclass(hwnd, wnd_proc_sub, 4, SEND_NEST); + ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 4, SEND_NEST); + ok(ret == TRUE, "Expected TRUE\n"); SendMessageA(hwnd, WM_USER, 1, 1); ok_sequence(Sub_MixAndNestTest, "Mix and nest"); - pSetWindowSubclass(hwnd, wnd_proc_sub, 4, SEND_NEST | DELETE_SELF); + ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 4, SEND_NEST | DELETE_SELF); + ok(ret == TRUE, "Expected TRUE\n"); SendMessageA(hwnd, WM_USER, 1, 1); ok_sequence(Sub_MixNestDelTest, "Mix, nest, del"); - pSetWindowSubclass(hwnd, wnd_proc_sub, 4, 0); - pSetWindowSubclass(hwnd, wnd_proc_sub, 5, DELETE_PREV); + ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 4, 0); + ok(ret == TRUE, "Expected TRUE\n"); + ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 5, DELETE_PREV); + ok(ret == TRUE, "Expected TRUE\n"); SendMessageA(hwnd, WM_USER, 1, 1); ok_sequence(Sub_MixDelPrevTest, "Mix and del prev"); + ret = pSetWindowSubclass(NULL, wnd_proc_sub, 1, 0); + ok(ret == FALSE, "Expected FALSE\n"); + + ret = pSetWindowSubclass(hwnd, NULL, 1, 0); + ok(ret == FALSE, "Expected FALSE\n"); + DestroyWindow(hwnd); } -- 2.17.1

1 0

[PATCH 2/2] winhttp: Set last error in WinHttpQueryAuthSchemes when no auth scheme is found.
by Jacek Caban 19 Sep '18

19 Sep '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/winhttp/request.c | 1 + dlls/winhttp/tests/winhttp.c | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-)

3 2

[PATCH 1/2] winhttp: Modify index only if query_headers succeeded.
by Jacek Caban 19 Sep '18

19 Sep '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/winhttp/request.c | 3 +-- dlls/winhttp/tests/winhttp.c | 39 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 39 insertions(+), 3 deletions(-)

3 3

[PATCH 1/4] comctl32/listbox: SetCount must fail if LBS_NODATA is not set
by Gabriel Ivăncescu 19 Sep '18

19 Sep '18

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- dlls/comctl32/listbox.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/dlls/comctl32/listbox.c b/dlls/comctl32/listbox.c index 2137ef8..a49a26c 100644 --- a/dlls/comctl32/listbox.c +++ b/dlls/comctl32/listbox.c @@ -1752,7 +1752,7 @@ static LRESULT LISTBOX_SetCount( LB_DESCR *descr, INT count ) { LRESULT ret; - if (HAS_STRINGS(descr)) + if (!(descr->style & LBS_NODATA)) { SetLastError(ERROR_SETCOUNT_ON_BAD_LB); return LB_ERR; @@ -2518,6 +2518,9 @@ static BOOL LISTBOX_Create( HWND hwnd, LPHEADCOMBO lphc ) if (descr->style & LBS_OWNERDRAWVARIABLE) descr->style |= LBS_NOINTEGRALHEIGHT; descr->item_height = LISTBOX_SetFont( descr, 0 ); + if ((descr->style & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE | LBS_HASSTRINGS | LBS_SORT)) != LBS_OWNERDRAWFIXED) + descr->style &= ~LBS_NODATA; + if (descr->style & LBS_OWNERDRAWFIXED) { if( descr->lphc && (descr->lphc->dwStyle & CBS_DROPDOWN)) -- 1.9.1

2 5

[PATCH 1/2] comctl32/listbox: Optimize SetCount partly
by Gabriel Ivăncescu 19 Sep '18

19 Sep '18

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- The case where count < descr->nb_items isn't really optimal, just stops redrawing right now. The other case (growing) should be optimal now, though. dlls/comctl32/listbox.c | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-) diff --git a/dlls/comctl32/listbox.c b/dlls/comctl32/listbox.c index 2137ef8..01588bb 100644 --- a/dlls/comctl32/listbox.c +++ b/dlls/comctl32/listbox.c @@ -1758,18 +1758,31 @@ static LRESULT LISTBOX_SetCount( LB_DESCR *descr, INT count ) return LB_ERR; } - /* FIXME: this is far from optimal... */ if (count > descr->nb_items) { - while (count > descr->nb_items) - if ((ret = LISTBOX_InsertString( descr, -1, 0 )) < 0) - return ret; + INT num = descr->nb_items; + if ((ret = LISTBOX_InitStorage(descr, count - num)) != LB_OKAY) + return ret; + memset(&descr->items[num], 0, (count - num) * sizeof(*descr->items)); + descr->nb_items = count; + + LISTBOX_UpdateScroll(descr); + LISTBOX_InvalidateItems(descr, num); + + /* If listbox was empty, set focus to the first item */ + if (count == 1) LISTBOX_SetCaretIndex(descr, 0, FALSE); } else if (count < descr->nb_items) { + /* FIXME: This is not really optimal */ + DWORD oldstyle = descr->style; + LISTBOX_SetRedraw(descr, FALSE); + while (count < descr->nb_items) if ((ret = LISTBOX_RemoveItem( descr, (descr->nb_items - 1) )) < 0) - return ret; + break; + if (!(oldstyle & LBS_NOREDRAW)) LISTBOX_SetRedraw(descr, TRUE); + if (ret < 0) return ret; } InvalidateRect( descr->self, NULL, TRUE ); -- 1.9.1

2 9

[PATCH v2 1/2] comctl32/listbox: Fix InitStorage heap extension
by Gabriel Ivăncescu 19 Sep '18

19 Sep '18

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- v2: Assume LB_ARRAY_GRANULARITY is a power of 2 and note it in the comments. Only increase the item array if we actually have to. Previously, sending for example just 1 to nb_items repeatedly would always increase the array by LB_ARRAY_GRANULARITY, even if there was plenty of space. dlls/comctl32/listbox.c | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/dlls/comctl32/listbox.c b/dlls/comctl32/listbox.c index 2137ef8..5c171ab 100644 --- a/dlls/comctl32/listbox.c +++ b/dlls/comctl32/listbox.c @@ -41,7 +41,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(listbox); -/* Items array granularity */ +/* Items array granularity; must be a power of 2 */ #define LB_ARRAY_GRANULARITY 16 /* Scrolling timeout in ms */ @@ -673,16 +673,18 @@ static LRESULT LISTBOX_InitStorage( LB_DESCR *descr, INT nb_items ) { LB_ITEMDATA *item; - nb_items += LB_ARRAY_GRANULARITY - 1; - nb_items -= (nb_items % LB_ARRAY_GRANULARITY); if (descr->items) { - nb_items += HeapSize( GetProcessHeap(), 0, descr->items ) / sizeof(*item); - item = HeapReAlloc( GetProcessHeap(), 0, descr->items, - nb_items * sizeof(LB_ITEMDATA)); + nb_items += descr->nb_items; + if (nb_items > HeapSize(GetProcessHeap(), 0, descr->items) / sizeof(*item)) + { + UINT n = (nb_items + LB_ARRAY_GRANULARITY - 1) & ~(LB_ARRAY_GRANULARITY - 1); + item = HeapReAlloc(GetProcessHeap(), 0, descr->items, n * sizeof(*item)); + } + else return LB_OKAY; } else { - item = HeapAlloc( GetProcessHeap(), 0, - nb_items * sizeof(LB_ITEMDATA)); + UINT n = (nb_items + LB_ARRAY_GRANULARITY - 1) & ~(LB_ARRAY_GRANULARITY - 1); + item = HeapAlloc(GetProcessHeap(), 0, n * sizeof(*item)); } if (!item) -- 1.9.1

1 1

[PATCH 3/4] msi/tests: Also test full range of properties for MsiSummaryInfoSetPropertyW.
by Dmitry Timoshkov 19 Sep '18

19 Sep '18

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msi/tests/custom.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/dlls/msi/tests/custom.c b/dlls/msi/tests/custom.c index f06aee0675..c6e9f1eb52 100644 --- a/dlls/msi/tests/custom.c +++ b/dlls/msi/tests/custom.c @@ -512,10 +512,10 @@ static void test_db(MSIHANDLE hinst) { r = MsiSummaryInfoSetPropertyA(suminfo, i, prop_type[i], 1252, &ft, ""); ok(hinst, r == ERROR_FUNCTION_FAILED, "%u: got %u\n", i, r); - } - r = MsiSummaryInfoSetPropertyW(suminfo, PID_CODEPAGE, VT_I2, 1252, &ft, NULL); - ok(hinst, r == ERROR_FUNCTION_FAILED, "got %u\n", r); + r = MsiSummaryInfoSetPropertyW(suminfo, i, prop_type[i], 1252, &ft, NULL); + ok(hinst, r == ERROR_FUNCTION_FAILED, "%u: got %u\n", i, r); + } r = MsiCloseHandle(suminfo); ok(hinst, !r, "got %u\n", r); -- 2.17.1

5 5

[PATCH 1/2] comctl32/listbox: Fix InitStorage heap extension
by Gabriel Ivăncescu 19 Sep '18

19 Sep '18

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- Only increase the item array if we actually have to. Previously, sending 1 to nb_items repeatedly would always increase the array by LB_ARRAY_GRANULARITY, even if there was plenty of space. dlls/comctl32/listbox.c | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/dlls/comctl32/listbox.c b/dlls/comctl32/listbox.c index 2137ef8..9cd89ff 100644 --- a/dlls/comctl32/listbox.c +++ b/dlls/comctl32/listbox.c @@ -673,16 +673,20 @@ static LRESULT LISTBOX_InitStorage( LB_DESCR *descr, INT nb_items ) { LB_ITEMDATA *item; - nb_items += LB_ARRAY_GRANULARITY - 1; - nb_items -= (nb_items % LB_ARRAY_GRANULARITY); if (descr->items) { - nb_items += HeapSize( GetProcessHeap(), 0, descr->items ) / sizeof(*item); - item = HeapReAlloc( GetProcessHeap(), 0, descr->items, - nb_items * sizeof(LB_ITEMDATA)); + nb_items += descr->nb_items; + if (nb_items > HeapSize(GetProcessHeap(), 0, descr->items) / sizeof(*item)) + { + UINT n = nb_items + LB_ARRAY_GRANULARITY - 1; + item = HeapReAlloc(GetProcessHeap(), 0, descr->items, + (n - n % LB_ARRAY_GRANULARITY) * sizeof(*item)); + } + else return LB_OKAY; } else { - item = HeapAlloc( GetProcessHeap(), 0, - nb_items * sizeof(LB_ITEMDATA)); + UINT n = nb_items + LB_ARRAY_GRANULARITY - 1; + item = HeapAlloc(GetProcessHeap(), 0, + (n - n % LB_ARRAY_GRANULARITY) * sizeof(*item)); } if (!item) -- 1.9.1

2 3

[PATCH] d2d1: Implement CreateBitmapFromDxgiSurface().
by Nikolay Sivov 19 Sep '18

19 Sep '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/d2d1/device.c | 28 ++++++++++++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-) diff --git a/dlls/d2d1/device.c b/dlls/d2d1/device.c index d779fb0a97..d20377b5c2 100644 --- a/dlls/d2d1/device.c +++ b/dlls/d2d1/device.c @@ -1825,9 +1825,33 @@ static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateColorContextFromWicCol static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateBitmapFromDxgiSurface(ID2D1DeviceContext *iface, IDXGISurface *surface, const D2D1_BITMAP_PROPERTIES1 *desc, ID2D1Bitmap1 **bitmap) { - FIXME("iface %p, surface %p, desc %p, bitmap %p stub!\n", iface, surface, desc, bitmap); + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); + D2D1_BITMAP_PROPERTIES1 bitmap_desc; + struct d2d_bitmap *object; + HRESULT hr; - return E_NOTIMPL; + TRACE("iface %p, surface %p, desc %p, bitmap %p.\n", iface, surface, desc, bitmap); + + if (!desc) + { + DXGI_SURFACE_DESC surface_desc; + + if (FAILED(hr = IDXGISurface_GetDesc(surface, &surface_desc))) + { + WARN("Failed to get surface desc, hr %#x.\n", hr); + return hr; + } + + memset(&bitmap_desc, 0, sizeof(bitmap_desc)); + bitmap_desc.pixelFormat.format = surface_desc.Format; + bitmap_desc.bitmapOptions = D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW; + desc = &bitmap_desc; + } + + if (SUCCEEDED(hr = d2d_bitmap_create_shared(context, &IID_IDXGISurface, surface, desc, &object))) + *bitmap = &object->ID2D1Bitmap1_iface; + + return hr; } static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateEffect(ID2D1DeviceContext *iface, -- 2.18.0

2 1

[PATCH 2/2] msi/tests: Add a test for repetitive MsiGetActiveDatabase calls.
by Dmitry Timoshkov 19 Sep '18

19 Sep '18

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msi/tests/custom.c | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/dlls/msi/tests/custom.c b/dlls/msi/tests/custom.c index c9ec82fd93..cd6cb0c378 100644 --- a/dlls/msi/tests/custom.c +++ b/dlls/msi/tests/custom.c @@ -281,7 +281,7 @@ static void test_db(MSIHANDLE hinst) VT_EMPTY, VT_EMPTY, VT_LPSTR, VT_EMPTY, VT_LPSTR, VT_EMPTY, VT_EMPTY, VT_EMPTY, VT_EMPTY, VT_I4, VT_I4, VT_EMPTY, VT_EMPTY, VT_EMPTY, VT_EMPTY }; - MSIHANDLE hdb, view, rec, rec2, suminfo; + MSIHANDLE hdb, hdb2, view, rec, rec2, suminfo; char buffer[10]; DWORD sz; UINT r, count, type, i; @@ -312,6 +312,17 @@ static void test_db(MSIHANDLE hinst) ok(hinst, sz == strlen(buffer), "got size %u\n", sz); ok(hinst, !strcmp(buffer, "Name"), "got '%s'\n", buffer); + /* Test MsiGetActiveDatabase + MsiDatabaseIsTablePersistent once again */ + hdb2 = MsiGetActiveDatabase(hinst); + ok(hinst, hdb2, "MsiGetActiveDatabase failed\n"); + ok(hinst, hdb2 != hdb, "db handles should be different\n"); + + r = MsiDatabaseIsTablePersistentA(hdb2, "Test"); + ok(hinst, r == MSICONDITION_TRUE, "got %u\n", r); + + r = MsiCloseHandle(hdb2); + ok(hinst, !r, "got %u\n", r); + r = MsiCloseHandle(rec2); ok(hinst, !r, "got %u\n", r); -- 2.17.1

3 2

[PATCH 1/2] msi/tests: Also test full range of properties for MsiSummaryInfoSetPropertyW. (v2)
by Dmitry Timoshkov 19 Sep '18

19 Sep '18

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msi/tests/custom.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/dlls/msi/tests/custom.c b/dlls/msi/tests/custom.c index f06aee0675..c9ec82fd93 100644 --- a/dlls/msi/tests/custom.c +++ b/dlls/msi/tests/custom.c @@ -510,12 +510,14 @@ static void test_db(MSIHANDLE hinst) for (i = 0; i < 20; i++) { + WCHAR emptyW[1] = { 0 }; + r = MsiSummaryInfoSetPropertyA(suminfo, i, prop_type[i], 1252, &ft, ""); ok(hinst, r == ERROR_FUNCTION_FAILED, "%u: got %u\n", i, r); - } - r = MsiSummaryInfoSetPropertyW(suminfo, PID_CODEPAGE, VT_I2, 1252, &ft, NULL); - ok(hinst, r == ERROR_FUNCTION_FAILED, "got %u\n", r); + r = MsiSummaryInfoSetPropertyW(suminfo, i, prop_type[i], 1252, &ft, emptyW); + ok(hinst, r == ERROR_FUNCTION_FAILED, "%u: got %u\n", i, r); + } r = MsiCloseHandle(suminfo); ok(hinst, !r, "got %u\n", r); -- 2.17.1

3 2

[PATCH 01/10] opcservices/uri: Fix IsEqual() to work with OPC URI objects.
by Nikolay Sivov 19 Sep '18

19 Sep '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/opcservices/tests/opcservices.c | 15 ++++++++++++--- dlls/opcservices/uri.c | 16 +++++++++++++++- 2 files changed, 27 insertions(+), 4 deletions(-) diff --git a/dlls/opcservices/tests/opcservices.c b/dlls/opcservices/tests/opcservices.c index 17b7609739..a0621760b4 100644 --- a/dlls/opcservices/tests/opcservices.c +++ b/dlls/opcservices/tests/opcservices.c @@ -521,7 +521,7 @@ static void test_rel_part_uri(void) IOpcPartUri *rel_uri2; IOpcUri *source_uri2; IUnknown *unk = NULL; - BOOL ret = FALSE; + BOOL ret; BSTR str; hr = IOpcPartUri_GetSourceUri(rel_uri, &source_uri); @@ -529,11 +529,20 @@ static void test_rel_part_uri(void) hr = IOpcPartUri_GetSourceUri(rel_uri, &source_uri2); ok(SUCCEEDED(hr), "Failed to get source uri, hr %#x.\n", hr); ok(source_uri != source_uri2, "Unexpected instance.\n"); + + hr = IOpcUri_IsEqual(source_uri, NULL, NULL); + ok(hr == E_POINTER, "Unexpected hr %#x.\n", hr); + + ret = 123; + hr = IOpcUri_IsEqual(source_uri, NULL, &ret); + ok(is_root ? hr == E_POINTER : hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(is_root ? ret == 123 : !ret, "Unexpected result.\n"); + + ret = FALSE; hr = IOpcUri_IsEqual(source_uri, (IUri *)source_uri2, &ret); - todo_wine { ok(SUCCEEDED(hr), "IsEqual failed, hr %#x.\n", hr); ok(ret, "Expected equal uris.\n"); - } + hr = IOpcUri_QueryInterface(source_uri, &IID_IOpcPartUri, (void **)&unk); ok(hr == (is_root ? E_NOINTERFACE : S_OK), "Unexpected hr %#x, %s.\n", hr, rel_part_uri_tests[i].uri); if (unk) diff --git a/dlls/opcservices/uri.c b/dlls/opcservices/uri.c index ddb2c05daf..fa5ddbcde8 100644 --- a/dlls/opcservices/uri.c +++ b/dlls/opcservices/uri.c @@ -312,7 +312,21 @@ static HRESULT WINAPI opc_uri_IsEqual(IOpcPartUri *iface, IUri *comparand, BOOL TRACE("iface %p, comparand %p, is_equal %p.\n", iface, comparand, is_equal); - return IUri_IsEqual(uri->uri, comparand, is_equal); + if (!is_equal) + return E_POINTER; + + if (!comparand) + { + if (uri->is_part_uri) + { + *is_equal = FALSE; + return S_OK; + } + + return E_POINTER; + } + + return IUri_IsEqual(comparand, uri->uri, is_equal); } static HRESULT WINAPI opc_uri_GetRelationshipsPartUri(IOpcPartUri *iface, IOpcPartUri **part_uri) -- 2.18.0

1 9

[PATCH resend] msvcrt: Add DECLSPEC_HOTPATCH to functions patched by libtcmalloc
by Alex Henrie 19 Sep '18

19 Sep '18

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=45199 Signed-off-by: Alex Henrie <alexhenrie24(a)gmail.com> --- dlls/msvcrt/heap.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/dlls/msvcrt/heap.c b/dlls/msvcrt/heap.c index 7ea80a3a50..b4f11d8ef4 100644 --- a/dlls/msvcrt/heap.c +++ b/dlls/msvcrt/heap.c @@ -21,6 +21,7 @@ * handler and non atomic heap operations */ +#include "config.h" #include "msvcrt.h" #include "mtdll.h" #include "wine/debug.h" @@ -127,7 +128,7 @@ static MSVCRT_size_t msvcrt_heap_size(void *ptr) /********************************************************************* * ??2@YAPAXI@Z (MSVCRT.@) */ -void* CDECL MSVCRT_operator_new(MSVCRT_size_t size) +void* CDECL DECLSPEC_HOTPATCH MSVCRT_operator_new(MSVCRT_size_t size) { void *retval; int freed; @@ -169,7 +170,7 @@ void* CDECL MSVCRT_operator_new_dbg(MSVCRT_size_t size, int type, const char *fi /********************************************************************* * ??3@YAXPAX@Z (MSVCRT.@) */ -void CDECL MSVCRT_operator_delete(void *mem) +void CDECL DECLSPEC_HOTPATCH MSVCRT_operator_delete(void *mem) { TRACE("(%p)\n", mem); msvcrt_heap_free(mem); @@ -394,7 +395,7 @@ size_t CDECL _aligned_msize(void *p, MSVCRT_size_t alignment, MSVCRT_size_t offs /********************************************************************* * calloc (MSVCRT.@) */ -void* CDECL MSVCRT_calloc(MSVCRT_size_t count, MSVCRT_size_t size) +void* CDECL DECLSPEC_HOTPATCH MSVCRT_calloc(MSVCRT_size_t count, MSVCRT_size_t size) { MSVCRT_size_t bytes = count*size; @@ -420,7 +421,7 @@ void* CDECL _calloc_base(MSVCRT_size_t count, MSVCRT_size_t size) /********************************************************************* * free (MSVCRT.@) */ -void CDECL MSVCRT_free(void* ptr) +void CDECL DECLSPEC_HOTPATCH MSVCRT_free(void* ptr) { msvcrt_heap_free(ptr); } @@ -459,7 +460,7 @@ void* CDECL _malloc_base(MSVCRT_size_t size) /********************************************************************* * realloc (MSVCRT.@) */ -void* CDECL MSVCRT_realloc(void* ptr, MSVCRT_size_t size) +void* CDECL DECLSPEC_HOTPATCH MSVCRT_realloc(void* ptr, MSVCRT_size_t size) { if (!ptr) return MSVCRT_malloc(size); if (size) return msvcrt_heap_realloc(0, ptr, size); -- 2.19.0

2 1

[PATCH] dbghelp: Fix memory leak in SymInitializeW() (Coverity).
by Józef Kucia 19 Sep '18

19 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/dbghelp/dbghelp.c | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/dlls/dbghelp/dbghelp.c b/dlls/dbghelp/dbghelp.c index 5685c25cd076..a085cd140ef7 100644 --- a/dlls/dbghelp/dbghelp.c +++ b/dlls/dbghelp/dbghelp.c @@ -298,7 +298,8 @@ BOOL WINAPI SymInitializeW(HANDLE hProcess, PCWSTR UserSearchPath, BOOL fInvadeP TRACE("(%p %s %u)\n", hProcess, debugstr_w(UserSearchPath), fInvadeProcess); - if (process_find_by_handle(hProcess)){ + if (process_find_by_handle(hProcess)) + { WARN("the symbols for this process have already been initialized!\n"); /* MSDN says to only call this function once unless SymCleanup() has been called since the last call. @@ -307,15 +308,15 @@ BOOL WINAPI SymInitializeW(HANDLE hProcess, PCWSTR UserSearchPath, BOOL fInvadeP return TRUE; } - pcs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pcs)); - if (!pcs) return FALSE; - - pcs->handle = hProcess; - IsWow64Process(GetCurrentProcess(), &wow64); if (!IsWow64Process(hProcess, &child_wow64)) return FALSE; + + pcs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pcs)); + if (!pcs) return FALSE; + + pcs->handle = hProcess; pcs->is_64bit = (sizeof(void *) == 8 || wow64) && !child_wow64; if (UserSearchPath) -- 2.16.4

1 0

[PATCH] urlmon/tests: Add IsEqual test for custom IUri implementation.
by Nikolay Sivov 19 Sep '18

19 Sep '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/urlmon/tests/uri.c | 240 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 240 insertions(+) diff --git a/dlls/urlmon/tests/uri.c b/dlls/urlmon/tests/uri.c index 7580a1302d..3c5e27c8d9 100644 --- a/dlls/urlmon/tests/uri.c +++ b/dlls/urlmon/tests/uri.c @@ -8515,7 +8515,225 @@ static void test_IUri_HasProperty(void) { } } +struct custom_uri { + IUri IUri_iface; + IUri *uri; +}; + +static inline struct custom_uri* impl_from_IUri(IUri *iface) +{ + return CONTAINING_RECORD(iface, struct custom_uri, IUri_iface); +} + +static HRESULT WINAPI custom_uri_QueryInterface(IUri *iface, REFIID iid, void **out) +{ + if (IsEqualIID(iid, &IID_IUri) || IsEqualIID(iid, &IID_IUnknown)) + { + *out = iface; + IUri_AddRef(iface); + return S_OK; + } + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI custom_uri_AddRef(IUri *iface) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_AddRef(uri->uri); +} + +static ULONG WINAPI custom_uri_Release(IUri *iface) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_Release(uri->uri); +} + +static HRESULT WINAPI custom_uri_GetPropertyBSTR(IUri *iface, Uri_PROPERTY property, BSTR *value, DWORD flags) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetPropertyBSTR(uri->uri, property, value, flags); +} + +static HRESULT WINAPI custom_uri_GetPropertyLength(IUri *iface, Uri_PROPERTY property, DWORD *length, DWORD flags) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetPropertyLength(uri->uri, property, length, flags); +} + +static HRESULT WINAPI custom_uri_GetPropertyDWORD(IUri *iface, Uri_PROPERTY property, DWORD *value, DWORD flags) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetPropertyDWORD(uri->uri, property, value, flags); +} + +static HRESULT WINAPI custom_uri_HasProperty(IUri *iface, Uri_PROPERTY property, BOOL *has_property) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_HasProperty(uri->uri, property, has_property); +} + +static HRESULT WINAPI custom_uri_GetAbsoluteUri(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetAuthority(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetDisplayUri(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetDomain(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetExtension(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetFragment(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetHost(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetPassword(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetPath(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetPathAndQuery(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetQuery(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetRawUri(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetSchemeName(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetSchemeName(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetUserInfo(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetUserInfo(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetUserName(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetUserName(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetHostType(IUri *iface, DWORD *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetHostType(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetPort(IUri *iface, DWORD *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetPort(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetScheme(IUri *iface, DWORD *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetScheme(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetZone(IUri *iface, DWORD *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetZone(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetProperties(IUri *iface, DWORD *flags) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetProperties(uri->uri, flags); +} + +static HRESULT WINAPI custom_uri_IsEqual(IUri *iface, IUri *pUri, BOOL *is_equal) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_IsEqual(uri->uri, pUri, is_equal); +} + +static const IUriVtbl custom_uri_vtbl = +{ + custom_uri_QueryInterface, + custom_uri_AddRef, + custom_uri_Release, + custom_uri_GetPropertyBSTR, + custom_uri_GetPropertyLength, + custom_uri_GetPropertyDWORD, + custom_uri_HasProperty, + custom_uri_GetAbsoluteUri, + custom_uri_GetAuthority, + custom_uri_GetDisplayUri, + custom_uri_GetDomain, + custom_uri_GetExtension, + custom_uri_GetFragment, + custom_uri_GetHost, + custom_uri_GetPassword, + custom_uri_GetPath, + custom_uri_GetPathAndQuery, + custom_uri_GetQuery, + custom_uri_GetRawUri, + custom_uri_GetSchemeName, + custom_uri_GetUserInfo, + custom_uri_GetUserName, + custom_uri_GetHostType, + custom_uri_GetPort, + custom_uri_GetScheme, + custom_uri_GetZone, + custom_uri_GetProperties, + custom_uri_IsEqual, +}; + static void test_IUri_IsEqual(void) { + struct custom_uri custom_uri; IUri *uriA, *uriB; BOOL equal; HRESULT hres; @@ -8537,9 +8755,21 @@ static void test_IUri_IsEqual(void) { hres = IUri_IsEqual(uriA, uriB, NULL); ok(hres == E_POINTER, "Error: IsEqual returned 0x%08x, expected 0x%08x.\n", hres, E_POINTER); + equal = FALSE; + hres = IUri_IsEqual(uriA, uriA, &equal); + ok(hres == S_OK, "Error: IsEqual returned 0x%08x, expected 0x%08x.\n", hres, S_OK); + ok(equal, "Error: Expected equal URIs.\n"); + + equal = FALSE; + hres = IUri_IsEqual(uriA, uriB, &equal); + ok(hres == S_OK, "Error: IsEqual returned 0x%08x, expected 0x%08x.\n", hres, S_OK); + ok(equal, "Error: Expected equal URIs.\n"); + IUri_Release(uriA); IUri_Release(uriB); + custom_uri.IUri_iface.lpVtbl = &custom_uri_vtbl; + for(i = 0; i < ARRAY_SIZE(equality_tests); ++i) { uri_equality test = equality_tests[i]; LPWSTR uriA_W, uriB_W; @@ -8561,6 +8791,16 @@ static void test_IUri_IsEqual(void) { ok(hres == S_OK, "Error: IsEqual returned 0x%08x, expected 0x%08x on equality_tests[%d].\n", hres, S_OK, i); ok(equal == test.equal, "Error: Expected the comparison to be %d on equality_tests[%d].\n", test.equal, i); } + + custom_uri.uri = uriB; + + equal = -1; + hres = IUri_IsEqual(uriA, &custom_uri.IUri_iface, &equal); + todo_wine { + ok(hres == S_OK, "Error: IsEqual returned 0x%08x, expected 0x%08x on equality_tests[%d].\n", hres, S_OK, i); + ok(equal == test.equal, "Error: Expected the comparison to be %d on equality_tests[%d].\n", test.equal, i); + } + if(uriA) IUri_Release(uriA); if(uriB) IUri_Release(uriB); -- 2.18.0

2 1

[PATCH 1/4] testbot: Rename the patch analyzer to GetPatchImpacts().
by Francois Gouget 19 Sep '18

19 Sep '18

The returned structure is called $Impacts everywhere so this makes the naming more consistent. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- testbot/bin/WineRunBuild.pl | 2 +- testbot/lib/Build/Utils.pm | 2 +- testbot/lib/WineTestBot/PatchUtils.pm | 6 +++--- testbot/lib/WineTestBot/Patches.pm | 4 ++-- testbot/web/Submit.pl | 4 ++-- 5 files changed, 9 insertions(+), 9 deletions(-) diff --git a/testbot/bin/WineRunBuild.pl b/testbot/bin/WineRunBuild.pl index 11b41c67a..d9bedb533 100755 --- a/testbot/bin/WineRunBuild.pl +++ b/testbot/bin/WineRunBuild.pl @@ -446,7 +446,7 @@ FatalTAError(undef, $TAError) if (defined $TAError); # Grab the executables for the next steps # -my $Impacts = GetPatchImpact($FileName, "nounit"); +my $Impacts = GetPatchImpacts($FileName, "nounit"); my $StepDir = $Step->CreateDir(); foreach my $TestInfo (values %{$Impacts->{Tests}}) { diff --git a/testbot/lib/Build/Utils.pm b/testbot/lib/Build/Utils.pm index fd1b8467c..38a801260 100644 --- a/testbot/lib/Build/Utils.pm +++ b/testbot/lib/Build/Utils.pm @@ -113,7 +113,7 @@ sub ApplyPatch($$) return undef; } - my $Impacts = GetPatchImpact($PatchFile, "nounits"); + my $Impacts = GetPatchImpacts($PatchFile, "nounits"); if ($Impacts->{MakeMakefiles}) { InfoMsg "\nRunning make_makefiles\n"; diff --git a/testbot/lib/WineTestBot/PatchUtils.pm b/testbot/lib/WineTestBot/PatchUtils.pm index 7049694aa..4a1761afb 100644 --- a/testbot/lib/WineTestBot/PatchUtils.pm +++ b/testbot/lib/WineTestBot/PatchUtils.pm @@ -31,7 +31,7 @@ the Wine builds. =cut use Exporter 'import'; -our @EXPORT = qw(GetPatchImpact UpdateWineData GetBuildTimeout); +our @EXPORT = qw(GetPatchImpacts UpdateWineData GetBuildTimeout); use List::Util qw(min max); @@ -249,7 +249,7 @@ sub _HandleFile($$$) =pod =over 12 -=item C<GetPatchImpact()> +=item C<GetPatchImpacts()> Analyzes a patch and returns a hashtable describing the impact it has on the Wine build: whether it requires updating the makefiles, re-running autoconf or @@ -258,7 +258,7 @@ configure, whether it impacts the tests, etc. =back =cut -sub GetPatchImpact($;$$) +sub GetPatchImpacts($;$$) { my ($PatchFileName, $NoUnits, $PastImpacts) = @_; diff --git a/testbot/lib/WineTestBot/Patches.pm b/testbot/lib/WineTestBot/Patches.pm index 390b1611c..a052c5a8c 100644 --- a/testbot/lib/WineTestBot/Patches.pm +++ b/testbot/lib/WineTestBot/Patches.pm @@ -133,8 +133,8 @@ sub Submit($$$) my ($self, $PatchFileName, $IsSet) = @_; my $PastImpacts; - $PastImpacts = GetPatchImpact($PatchFileName) if ($IsSet); - my $Impacts = GetPatchImpact("$DataDir/patches/" . $self->Id, undef, $PastImpacts); + $PastImpacts = GetPatchImpacts($PatchFileName) if ($IsSet); + my $Impacts = GetPatchImpacts("$DataDir/patches/" . $self->Id, undef, $PastImpacts); if (!$Impacts->{WineBuild} and !$Impacts->{ModuleBuild} and !$Impacts->{TestBuild}) diff --git a/testbot/web/Submit.pl b/testbot/web/Submit.pl index 621b01728..fe101042c 100644 --- a/testbot/web/Submit.pl +++ b/testbot/web/Submit.pl @@ -597,7 +597,7 @@ sub DetermineFileType($$) my ($ErrMessage, $ExeBase, $TestUnit); if ($FileType eq "unknown") { - my $Impacts = GetPatchImpact($FileName); + my $Impacts = GetPatchImpacts($FileName); if ($Impacts->{UnitCount} == 0) { $ErrMessage = "Patch doesn't affect tests"; @@ -781,7 +781,7 @@ sub OnSubmit($) if ($FileType eq "patch") { my $TmpStagingFullPath = $self->GetTmpStagingFullPath($BaseName); - $Impacts = GetPatchImpact($TmpStagingFullPath); + $Impacts = GetPatchImpacts($TmpStagingFullPath); } my $BuildStep; -- 2.18.0

1 3

[PATCH 4/4] msi/tests: Add a test for repetitive MsiGetActiveDatabase calls.
by Dmitry Timoshkov 19 Sep '18

19 Sep '18

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msi/tests/custom.c | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/dlls/msi/tests/custom.c b/dlls/msi/tests/custom.c index c6e9f1eb52..1694e93fde 100644 --- a/dlls/msi/tests/custom.c +++ b/dlls/msi/tests/custom.c @@ -281,7 +281,7 @@ static void test_db(MSIHANDLE hinst) VT_EMPTY, VT_EMPTY, VT_LPSTR, VT_EMPTY, VT_LPSTR, VT_EMPTY, VT_EMPTY, VT_EMPTY, VT_EMPTY, VT_I4, VT_I4, VT_EMPTY, VT_EMPTY, VT_EMPTY, VT_EMPTY }; - MSIHANDLE hdb, view, rec, rec2, suminfo; + MSIHANDLE hdb, hdb2, view, rec, rec2, suminfo; char buffer[10]; DWORD sz; UINT r, count, type, i; @@ -312,6 +312,17 @@ static void test_db(MSIHANDLE hinst) ok(hinst, sz == strlen(buffer), "got size %u\n", sz); ok(hinst, !strcmp(buffer, "Name"), "got '%s'\n", buffer); + /* Test MsiGetActiveDatabase + MsiDatabaseIsTablePersistent once again */ + hdb2 = MsiGetActiveDatabase(hinst); + ok(hinst, hdb2, "MsiGetActiveDatabase failed\n"); + ok(hinst, hdb2 != hdb, "db handles should be different\n"); + + r = MsiDatabaseIsTablePersistentA(hdb2, "Test"); + ok(hinst, r == MSICONDITION_TRUE, "got %u\n", r); + + r = MsiCloseHandle(hdb2); + ok(hinst, !r, "got %u\n", r); + r = MsiCloseHandle(rec2); ok(hinst, !r, "got %u\n", r); -- 2.17.1

2 1

[PATCH 2/4] msi: Do not attempt to copy a not string property in MsiSummaryInfoGetProperty.
by Dmitry Timoshkov 19 Sep '18

19 Sep '18

This patch fixes the crashes when running the tests under Wine. Currently the crashes are hidden by a custom action exception handler. Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msi/suminfo.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/dlls/msi/suminfo.c b/dlls/msi/suminfo.c index af3458a0a8..98f6330d9f 100644 --- a/dlls/msi/suminfo.c +++ b/dlls/msi/suminfo.c @@ -758,8 +758,10 @@ UINT WINAPI MsiSummaryInfoGetPropertyA( } __ENDTRY - if (!r) + if (!r && buf) + { r = msi_strncpyWtoA( buf, -1, szValueBuf, pcchValueBuf, TRUE ); + } midl_user_free( buf ); return r; @@ -808,7 +810,7 @@ UINT WINAPI MsiSummaryInfoGetPropertyW( } __ENDTRY - if (!r) + if (!r && buf) r = msi_strncpyW( buf, -1, szValueBuf, pcchValueBuf ); midl_user_free( buf ); -- 2.17.1

2 1

[PATCH 1/4] msi: Move parameter checks to a common helper in MsiSummaryInfoSetProperty.
by Dmitry Timoshkov 19 Sep '18

19 Sep '18

Currently MsiSummaryInfoSetProperty tests don't have a chance to execute under Wine because the tests crash earlier, and the crashes are hidden by a custom action exception handler. This patch simplifies the next one. Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msi/suminfo.c | 44 ++++++++++++++++++++------------------------ 1 file changed, 20 insertions(+), 24 deletions(-) diff --git a/dlls/msi/suminfo.c b/dlls/msi/suminfo.c index 37c49d72e2..af3458a0a8 100644 --- a/dlls/msi/suminfo.c +++ b/dlls/msi/suminfo.c @@ -877,26 +877,32 @@ static UINT set_prop( MSISUMMARYINFO *si, UINT uiProperty, UINT type, return ERROR_SUCCESS; } -UINT WINAPI MsiSummaryInfoSetPropertyW( MSIHANDLE handle, UINT uiProperty, UINT uiDataType, - INT iValue, FILETIME *pftValue, LPCWSTR szValue ) +static UINT msi_set_prop( MSISUMMARYINFO *si, UINT uiProperty, UINT uiDataType, + INT iValue, FILETIME *pftValue, awcstring *str ) { - awcstring str; - MSISUMMARYINFO *si; - UINT type, ret; - - TRACE("%u, %u, %u, %d, %p, %s\n", handle, uiProperty, uiDataType, iValue, pftValue, - debugstr_w(szValue) ); - - type = get_type( uiProperty ); + UINT type = get_type( uiProperty ); if( type == VT_EMPTY || type != uiDataType ) return ERROR_DATATYPE_MISMATCH; - if( uiDataType == VT_LPSTR && !szValue ) + if( uiDataType == VT_LPSTR && !str->str.a ) return ERROR_INVALID_PARAMETER; if( uiDataType == VT_FILETIME && !pftValue ) return ERROR_INVALID_PARAMETER; + return set_prop( si, uiProperty, type, iValue, pftValue, str ); +} + +UINT WINAPI MsiSummaryInfoSetPropertyW( MSIHANDLE handle, UINT uiProperty, UINT uiDataType, + INT iValue, FILETIME *pftValue, LPCWSTR szValue ) +{ + awcstring str; + MSISUMMARYINFO *si; + UINT ret; + + TRACE("%u, %u, %u, %d, %p, %s\n", handle, uiProperty, uiDataType, iValue, pftValue, + debugstr_w(szValue) ); + if (!(si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO ))) { MSIHANDLE remote; @@ -913,7 +919,7 @@ UINT WINAPI MsiSummaryInfoSetPropertyW( MSIHANDLE handle, UINT uiProperty, UINT str.unicode = TRUE; str.str.w = szValue; - ret = set_prop( si, uiProperty, type, iValue, pftValue, &str ); + ret = msi_set_prop( si, uiProperty, uiDataType, iValue, pftValue, &str ); msiobj_release( &si->hdr ); return ret; } @@ -923,21 +929,11 @@ UINT WINAPI MsiSummaryInfoSetPropertyA( MSIHANDLE handle, UINT uiProperty, UINT { awcstring str; MSISUMMARYINFO *si; - UINT type, ret; + UINT ret; TRACE("%u, %u, %u, %d, %p, %s\n", handle, uiProperty, uiDataType, iValue, pftValue, debugstr_a(szValue) ); - type = get_type( uiProperty ); - if( type == VT_EMPTY || type != uiDataType ) - return ERROR_DATATYPE_MISMATCH; - - if( uiDataType == VT_LPSTR && !szValue ) - return ERROR_INVALID_PARAMETER; - - if( uiDataType == VT_FILETIME && !pftValue ) - return ERROR_INVALID_PARAMETER; - if (!(si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO ))) { MSIHANDLE remote; @@ -954,7 +950,7 @@ UINT WINAPI MsiSummaryInfoSetPropertyA( MSIHANDLE handle, UINT uiProperty, UINT str.unicode = FALSE; str.str.a = szValue; - ret = set_prop( si, uiProperty, uiDataType, iValue, pftValue, &str ); + ret = msi_set_prop( si, uiProperty, uiDataType, iValue, pftValue, &str ); msiobj_release( &si->hdr ); return ret; } -- 2.17.1

2 1

[PATCH v8 1/5] shell32/autocomplete: Don't auto-append on control characters
by Gabriel Ivăncescu 19 Sep '18

19 Sep '18

We must not auto-append on control characters, most notably Backspace, but also ^X (cut) and so on. Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- v8: Don't exclude ^V. dlls/shell32/autocomplete.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/shell32/autocomplete.c b/dlls/shell32/autocomplete.c index 183b37b..b0c92c3 100644 --- a/dlls/shell32/autocomplete.c +++ b/dlls/shell32/autocomplete.c @@ -343,7 +343,7 @@ static LRESULT APIENTRY ACEditSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, case WM_CHAR: case WM_UNICHAR: ret = CallWindowProcW(This->wpOrigEditProc, hwnd, uMsg, wParam, lParam); - autocomplete_text(This, hwnd, (This->options & ACO_AUTOAPPEND) + autocomplete_text(This, hwnd, (This->options & ACO_AUTOAPPEND) && wParam >= ' ' ? autoappend_flag_yes : autoappend_flag_no); return ret; case WM_DESTROY: -- 1.9.1

2 9

[PATCH 1/5] quartz/tests: Test interfaces exposed by the filter graph.
by Zebediah Figura 19 Sep '18

19 Sep '18

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/quartz/tests/filtergraph.c | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/dlls/quartz/tests/filtergraph.c b/dlls/quartz/tests/filtergraph.c index 37304d6..82f895f 100644 --- a/dlls/quartz/tests/filtergraph.c +++ b/dlls/quartz/tests/filtergraph.c @@ -76,6 +76,46 @@ static IFilterGraph2 *create_graph(void) return ret; } +#define check_interface(a, b, c) check_interface_(__LINE__, a, b, c) +static void check_interface_(unsigned int line, void *iface_ptr, REFIID iid, BOOL supported) +{ + IUnknown *iface = iface_ptr; + HRESULT hr, expected_hr; + IUnknown *unk; + + expected_hr = supported ? S_OK : E_NOINTERFACE; + + hr = IUnknown_QueryInterface(iface, iid, (void **)&unk); + ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x, expected %#x.\n", hr, expected_hr); + if (SUCCEEDED(hr)) + IUnknown_Release(unk); +} + +static void test_interfaces(void) +{ + IFilterGraph2 *graph = create_graph(); + + check_interface(graph, &IID_IBasicAudio, TRUE); + check_interface(graph, &IID_IBasicVideo2, TRUE); + check_interface(graph, &IID_IFilterGraph2, TRUE); + check_interface(graph, &IID_IFilterMapper, TRUE); + check_interface(graph, &IID_IFilterMapper3, TRUE); + check_interface(graph, &IID_IGraphConfig, TRUE); + check_interface(graph, &IID_IGraphVersion, TRUE); + check_interface(graph, &IID_IMediaControl, TRUE); + check_interface(graph, &IID_IMediaEvent, TRUE); + check_interface(graph, &IID_IMediaFilter, TRUE); + check_interface(graph, &IID_IMediaEventSink, TRUE); + check_interface(graph, &IID_IMediaPosition, TRUE); + check_interface(graph, &IID_IMediaSeeking, TRUE); + check_interface(graph, &IID_IObjectWithSite, TRUE); + check_interface(graph, &IID_IVideoWindow, TRUE); + + check_interface(graph, &IID_IBaseFilter, FALSE); + + IFilterGraph2_Release(graph); +} + static void test_basic_video(IFilterGraph2 *graph) { IBasicVideo* pbv; @@ -1827,6 +1867,7 @@ START_TEST(filtergraph) { CoInitializeEx(NULL, COINIT_MULTITHREADED); + test_interfaces(); test_render_run(avifile); test_render_run(mpegfile); test_enum_filters(); -- 2.7.4

1 4

Is WINE compatible with .NET framework
by mrt303xx＠aol.com 18 Sep '18

18 Sep '18

I built a simple test app (displays a empty WinForm with no content) to test .NET and it fails to open? Are the some settings I have missed. I used WineTricks to install dotnet462 and I installed .NET 2.1 for Mac on my machine, but it still fails

1 0

[PATCH] uxtheme: Use the ARRAY_SIZE() macro
by Michael Stefaniuc 18 Sep '18

18 Sep '18

Signed-off-by: Michael Stefaniuc <mstefani(a)winehq.org> --- dlls/uxtheme/draw.c | 5 ++--- dlls/uxtheme/metric.c | 2 +- dlls/uxtheme/msstyles.c | 22 +++++++++++----------- dlls/uxtheme/property.c | 4 ++-- dlls/uxtheme/stylemap.c | 2 +- dlls/uxtheme/system.c | 46 +++++++++++++++++++++------------------------- 6 files changed, 38 insertions(+), 43 deletions(-) diff --git a/dlls/uxtheme/draw.c b/dlls/uxtheme/draw.c index d07d0753da..69c53b9ebc 100644 --- a/dlls/uxtheme/draw.c +++ b/dlls/uxtheme/draw.c @@ -198,8 +198,7 @@ static PTHEME_PROPERTY UXTHEME_SelectImage(HTHEME hTheme, HDC hdc, int iPartId, HBITMAP hBmp; BOOL hasAlpha; - lstrcpynW(szPath, fileProp->lpValue, - min(fileProp->dwValueLen+1, sizeof(szPath)/sizeof(szPath[0]))); + lstrcpynW(szPath, fileProp->lpValue, min(fileProp->dwValueLen+1, ARRAY_SIZE(szPath))); hBmp = MSSTYLES_LoadBitmap(hTheme, szPath, &hasAlpha); if(!hBmp) continue; @@ -245,7 +244,7 @@ static HRESULT UXTHEME_LoadImage(HTHEME hTheme, HDC hdc, int iPartId, int iState FIXME("Couldn't determine image for part/state %d/%d, invalid theme?\n", iPartId, iStateId); return E_PROP_ID_UNSUPPORTED; } - lstrcpynW(szPath, tp->lpValue, min(tp->dwValueLen+1, sizeof(szPath)/sizeof(szPath[0]))); + lstrcpynW(szPath, tp->lpValue, min(tp->dwValueLen+1, ARRAY_SIZE(szPath))); *hBmp = MSSTYLES_LoadBitmap(hTheme, szPath, hasImageAlpha); if(!*hBmp) { TRACE("Failed to load bitmap %s\n", debugstr_w(szPath)); diff --git a/dlls/uxtheme/metric.c b/dlls/uxtheme/metric.c index daf17ca35a..5f6c36f5cf 100644 --- a/dlls/uxtheme/metric.c +++ b/dlls/uxtheme/metric.c @@ -181,7 +181,7 @@ int WINAPI GetThemeSysSize(HTHEME hTheme, int iSizeID) }; if(hTheme) { - for(i=0; i<sizeof(metricMap)/sizeof(metricMap[0]); i+=2) { + for(i=0; i<ARRAY_SIZE(metricMap); i+=2) { if(metricMap[i] == iSizeID) { id = metricMap[i+1]; break; diff --git a/dlls/uxtheme/msstyles.c b/dlls/uxtheme/msstyles.c index fe91494afd..bc8eca7b34 100644 --- a/dlls/uxtheme/msstyles.c +++ b/dlls/uxtheme/msstyles.c @@ -344,7 +344,7 @@ static BOOL MSSTYLES_ParseIniSectionName(LPCWSTR lpSection, DWORD dwLen, LPWSTR WCHAR state[60] = {'\0'}; LPWSTR tmp; LPWSTR comp; - lstrcpynW(sec, lpSection, min(dwLen+1, sizeof(sec)/sizeof(sec[0]))); + lstrcpynW(sec, lpSection, min(dwLen+1, ARRAY_SIZE(sec))); *szAppName = 0; *szClassName = 0; @@ -369,17 +369,17 @@ static BOOL MSSTYLES_ParseIniSectionName(LPCWSTR lpSection, DWORD dwLen, LPWSTR tmp = strchrW(comp, '('); if(tmp) { *tmp++ = 0; - lstrcpynW(part, comp, sizeof(part)/sizeof(part[0])); + lstrcpynW(part, comp, ARRAY_SIZE(part)); comp = tmp; /* now get the state */ tmp = strchrW(comp, ')'); if (!tmp) return FALSE; *tmp = 0; - lstrcpynW(state, comp, sizeof(state)/sizeof(state[0])); + lstrcpynW(state, comp, ARRAY_SIZE(state)); } else { - lstrcpynW(part, comp, sizeof(part)/sizeof(part[0])); + lstrcpynW(part, comp, ARRAY_SIZE(part)); } } else { @@ -393,7 +393,7 @@ static BOOL MSSTYLES_ParseIniSectionName(LPCWSTR lpSection, DWORD dwLen, LPWSTR if (!tmp) return FALSE; *tmp = 0; - lstrcpynW(state, comp, sizeof(state)/sizeof(state[0])); + lstrcpynW(state, comp, ARRAY_SIZE(state)); } else { lstrcpynW(szClassName, comp, MAX_THEME_CLASS_NAME); @@ -897,7 +897,7 @@ static void MSSTYLES_ParseThemeIni(PTHEME_FILE tf, BOOL setMetrics) parse_init_nonclient (&nonClientState); while((lpName=UXINI_GetNextValue(ini, &dwLen, &lpValue, &dwValueLen))) { - lstrcpynW(szPropertyName, lpName, min(dwLen+1, sizeof(szPropertyName)/sizeof(szPropertyName[0]))); + lstrcpynW(szPropertyName, lpName, min(dwLen+1, ARRAY_SIZE(szPropertyName))); if(MSSTYLES_LookupProperty(szPropertyName, &iPropertyPrimitive, &iPropertyId)) { if(iPropertyId >= TMT_FIRSTCOLOR && iPropertyId <= TMT_LASTCOLOR) { if (!parse_handle_color_property (&colorState, iPropertyId, @@ -948,7 +948,7 @@ static void MSSTYLES_ParseThemeIni(PTHEME_FILE tf, BOOL setMetrics) ps = MSSTYLES_AddPartState(cls, iPartId, iStateId); while((lpName=UXINI_GetNextValue(ini, &dwLen, &lpValue, &dwValueLen))) { - lstrcpynW(szPropertyName, lpName, min(dwLen+1, sizeof(szPropertyName)/sizeof(szPropertyName[0]))); + lstrcpynW(szPropertyName, lpName, min(dwLen+1, ARRAY_SIZE(szPropertyName))); if(MSSTYLES_LookupProperty(szPropertyName, &iPropertyPrimitive, &iPropertyId)) { MSSTYLES_AddProperty(ps, iPropertyPrimitive, iPropertyId, lpValue, dwValueLen, isGlobal); } @@ -1014,13 +1014,13 @@ PTHEME_CLASS MSSTYLES_OpenThemeClass(LPCWSTR pszAppName, LPCWSTR pszClassList) start = pszClassList; while((end = strchrW(start, ';'))) { len = end-start; - lstrcpynW(szClassName, start, min(len+1, sizeof(szClassName)/sizeof(szClassName[0]))); + lstrcpynW(szClassName, start, min(len+1, ARRAY_SIZE(szClassName))); start = end+1; cls = MSSTYLES_FindClass(tfActiveTheme, pszAppName, szClassName); if(cls) break; } if(!cls && *start) { - lstrcpynW(szClassName, start, sizeof(szClassName)/sizeof(szClassName[0])); + lstrcpynW(szClassName, start, ARRAY_SIZE(szClassName)); cls = MSSTYLES_FindClass(tfActiveTheme, pszAppName, szClassName); } if(cls) { @@ -1120,7 +1120,7 @@ HBITMAP MSSTYLES_LoadBitmap (PTHEME_CLASS tc, LPCWSTR lpFilename, BOOL* hasAlpha WCHAR szFile[MAX_PATH]; LPWSTR tmp; PTHEME_IMAGE img; - lstrcpynW(szFile, lpFilename, sizeof(szFile)/sizeof(szFile[0])); + lstrcpynW(szFile, lpFilename, ARRAY_SIZE(szFile)); tmp = szFile; do { if(*tmp == '\\') *tmp = '_'; @@ -1273,7 +1273,7 @@ static HRESULT MSSTYLES_GetFont (LPCWSTR lpCur, LPCWSTR lpEnd, pFont->lfHeight = pointSize; pFont->lfWeight = FW_REGULAR; pFont->lfCharSet = DEFAULT_CHARSET; - while(MSSTYLES_GetNextToken(lpCur, lpEnd, &lpCur, attr, sizeof(attr)/sizeof(attr[0]))) { + while(MSSTYLES_GetNextToken(lpCur, lpEnd, &lpCur, attr, ARRAY_SIZE(attr))) { if(!lstrcmpiW(szBold, attr)) pFont->lfWeight = FW_BOLD; else if(!lstrcmpiW(szItalic, attr)) pFont->lfItalic = TRUE; else if(!lstrcmpiW(szUnderline, attr)) pFont->lfUnderline = TRUE; diff --git a/dlls/uxtheme/property.c b/dlls/uxtheme/property.c index 9dffbdde87..0e077aeec4 100644 --- a/dlls/uxtheme/property.c +++ b/dlls/uxtheme/property.c @@ -87,7 +87,7 @@ HRESULT WINAPI GetThemeEnumValue(HTHEME hTheme, int iPartId, int iStateId, if(!(tp = MSSTYLES_FindProperty(hTheme, iPartId, iStateId, TMT_ENUM, iPropId))) return E_PROP_ID_UNSUPPORTED; - hr = MSSTYLES_GetPropertyString(tp, val, sizeof(val)/sizeof(val[0])); + hr = MSSTYLES_GetPropertyString(tp, val, ARRAY_SIZE(val)); if(FAILED(hr)) return hr; if(!MSSTYLES_LookupEnum(val, iPropId, piVal)) @@ -262,7 +262,7 @@ HRESULT WINAPI GetThemeMetric(HTHEME hTheme, HDC hdc, int iPartId, case TMT_COLOR: return MSSTYLES_GetPropertyColor(tp, (COLORREF*)piVal); case TMT_ENUM: - hr = MSSTYLES_GetPropertyString(tp, val, sizeof(val)/sizeof(val[0])); + hr = MSSTYLES_GetPropertyString(tp, val, ARRAY_SIZE(val)); if(FAILED(hr)) return hr; if(!MSSTYLES_LookupEnum(val, iPropId, piVal)) diff --git a/dlls/uxtheme/stylemap.c b/dlls/uxtheme/stylemap.c index a310d4031d..19e3c93224 100644 --- a/dlls/uxtheme/stylemap.c +++ b/dlls/uxtheme/stylemap.c @@ -1051,7 +1051,7 @@ BOOL MSSTYLES_LookupPartState(LPCWSTR pszClass, LPCWSTR pszPart, LPCWSTR pszStat *iPartId = 0; *iStateId = 0; - for(i=0; i<sizeof(mapClass)/sizeof(mapClass[0]); i++) { + for(i=0; i<ARRAY_SIZE(mapClass); i++) { if(!lstrcmpiW(mapClass[i].pszClass, pszClass)) { map = mapClass[i].lpMap; if(pszPart) { diff --git a/dlls/uxtheme/system.c b/dlls/uxtheme/system.c index e11271ac2b..db497544f9 100644 --- a/dlls/uxtheme/system.c +++ b/dlls/uxtheme/system.c @@ -159,7 +159,7 @@ static void UXTHEME_LoadTheme(void) /* Get current theme configuration */ if(!RegOpenKeyW(HKEY_CURRENT_USER, szThemeManager, &hKey)) { TRACE("Loading theme config\n"); - buffsize = sizeof(tmp)/sizeof(tmp[0]); + buffsize = ARRAY_SIZE(tmp); if(!RegQueryValueExW(hKey, szThemeActive, NULL, NULL, (LPBYTE)tmp, &buffsize)) { bThemeActive = (tmp[0] != '0'); } @@ -167,10 +167,10 @@ static void UXTHEME_LoadTheme(void) bThemeActive = FALSE; TRACE("Failed to get ThemeActive: %d\n", GetLastError()); } - buffsize = sizeof(szCurrentColor)/sizeof(szCurrentColor[0]); + buffsize = ARRAY_SIZE(szCurrentColor); if(RegQueryValueExW(hKey, szColorName, NULL, NULL, (LPBYTE)szCurrentColor, &buffsize)) szCurrentColor[0] = '\0'; - buffsize = sizeof(szCurrentSize)/sizeof(szCurrentSize[0]); + buffsize = ARRAY_SIZE(szCurrentSize); if(RegQueryValueExW(hKey, szSizeName, NULL, NULL, (LPBYTE)szCurrentSize, &buffsize)) szCurrentSize[0] = '\0'; if (query_reg_path (hKey, szDllName, szCurrentTheme)) @@ -194,8 +194,8 @@ static void UXTHEME_LoadTheme(void) } else { /* Make sure the global color & size match the theme */ - lstrcpynW(szCurrentColor, pt->pszSelectedColor, sizeof(szCurrentColor)/sizeof(szCurrentColor[0])); - lstrcpynW(szCurrentSize, pt->pszSelectedSize, sizeof(szCurrentSize)/sizeof(szCurrentSize[0])); + lstrcpynW(szCurrentColor, pt->pszSelectedColor, ARRAY_SIZE(szCurrentColor)); + lstrcpynW(szCurrentSize, pt->pszSelectedSize, ARRAY_SIZE(szCurrentSize)); MSSTYLES_SetActiveTheme(pt, FALSE); TRACE("Theme active: %s %s %s\n", debugstr_w(szCurrentTheme), @@ -477,9 +477,9 @@ static HRESULT UXTHEME_SetActiveTheme(PTHEME_FILE tf) return hr; if(tf) { bThemeActive = TRUE; - lstrcpynW(szCurrentTheme, tf->szThemeFile, sizeof(szCurrentTheme)/sizeof(szCurrentTheme[0])); - lstrcpynW(szCurrentColor, tf->pszSelectedColor, sizeof(szCurrentColor)/sizeof(szCurrentColor[0])); - lstrcpynW(szCurrentSize, tf->pszSelectedSize, sizeof(szCurrentSize)/sizeof(szCurrentSize[0])); + lstrcpynW(szCurrentTheme, tf->szThemeFile, ARRAY_SIZE(szCurrentTheme)); + lstrcpynW(szCurrentColor, tf->pszSelectedColor, ARRAY_SIZE(szCurrentColor)); + lstrcpynW(szCurrentSize, tf->pszSelectedSize, ARRAY_SIZE(szCurrentSize)); } else { UXTHEME_RestoreSystemMetrics(); @@ -661,9 +661,9 @@ HTHEME WINAPI OpenThemeDataEx(HWND hwnd, LPCWSTR pszClassList, DWORD flags) if(bThemeActive) { - pszAppName = UXTHEME_GetWindowProperty(hwnd, atSubAppName, szAppBuff, sizeof(szAppBuff)/sizeof(szAppBuff[0])); + pszAppName = UXTHEME_GetWindowProperty(hwnd, atSubAppName, szAppBuff, ARRAY_SIZE(szAppBuff)); /* If SetWindowTheme was used on the window, that overrides the class list passed to this function */ - pszUseClassList = UXTHEME_GetWindowProperty(hwnd, atSubIdList, szClassBuff, sizeof(szClassBuff)/sizeof(szClassBuff[0])); + pszUseClassList = UXTHEME_GetWindowProperty(hwnd, atSubIdList, szClassBuff, ARRAY_SIZE(szClassBuff)); if(!pszUseClassList) pszUseClassList = pszClassList; @@ -837,7 +837,7 @@ HRESULT WINAPI GetThemeDocumentationProperty(LPCWSTR pszThemeName, /* Try to load from string resources */ hr = E_PROP_ID_UNSUPPORTED; if(MSSTYLES_LookupProperty(pszPropertyName, NULL, &iDocId)) { - for(i=0; i<sizeof(wDocToRes)/sizeof(wDocToRes[0]); i+=2) { + for(i=0; i<ARRAY_SIZE(wDocToRes); i+=2) { if(wDocToRes[i] == iDocId) { if(LoadStringW(pt->hTheme, wDocToRes[i+1], pszValueBuff, cchMaxValChars)) { hr = S_OK; @@ -1049,9 +1049,9 @@ HRESULT WINAPI EnumThemes(LPCWSTR pszThemePath, EnumThemeProc callback, && !(wfd.cFileName[0] == '.' && ((wfd.cFileName[1] == '.' && wfd.cFileName[2] == 0) || wfd.cFileName[1] == 0))) { wsprintfW(szPath, szFormat, szDir, wfd.cFileName, wfd.cFileName); - hr = GetThemeDocumentationProperty(szPath, szDisplayName, szName, sizeof(szName)/sizeof(szName[0])); + hr = GetThemeDocumentationProperty(szPath, szDisplayName, szName, ARRAY_SIZE(szName)); if(SUCCEEDED(hr)) - hr = GetThemeDocumentationProperty(szPath, szTooltip, szTip, sizeof(szTip)/sizeof(szTip[0])); + hr = GetThemeDocumentationProperty(szPath, szTooltip, szTip, ARRAY_SIZE(szTip)); if(SUCCEEDED(hr)) { TRACE("callback(%s,%s,%s,%p)\n", debugstr_w(szPath), debugstr_w(szName), debugstr_w(szTip), lpData); if(!callback(NULL, szPath, szName, szTip, NULL, lpData)) { @@ -1113,12 +1113,10 @@ HRESULT WINAPI EnumThemeColors(LPWSTR pszThemeFileName, LPWSTR pszSizeName, if(!dwColorNum && *tmp) { TRACE("%s\n", debugstr_w(tmp)); lstrcpyW(pszColorNames->szName, tmp); - LoadStringW (pt->hTheme, resourceId, - pszColorNames->szDisplayName, - sizeof (pszColorNames->szDisplayName) / sizeof (WCHAR)); - LoadStringW (pt->hTheme, resourceId+1000, - pszColorNames->szTooltip, - sizeof (pszColorNames->szTooltip) / sizeof (WCHAR)); + LoadStringW(pt->hTheme, resourceId, pszColorNames->szDisplayName, + ARRAY_SIZE(pszColorNames->szDisplayName)); + LoadStringW(pt->hTheme, resourceId+1000, pszColorNames->szTooltip, + ARRAY_SIZE(pszColorNames->szTooltip)); } else hr = E_PROP_ID_UNSUPPORTED; @@ -1173,12 +1171,10 @@ HRESULT WINAPI EnumThemeSizes(LPWSTR pszThemeFileName, LPWSTR pszColorName, if(!dwSizeNum && *tmp) { TRACE("%s\n", debugstr_w(tmp)); lstrcpyW(pszSizeNames->szName, tmp); - LoadStringW (pt->hTheme, resourceId, - pszSizeNames->szDisplayName, - sizeof (pszSizeNames->szDisplayName) / sizeof (WCHAR)); - LoadStringW (pt->hTheme, resourceId+1000, - pszSizeNames->szTooltip, - sizeof (pszSizeNames->szTooltip) / sizeof (WCHAR)); + LoadStringW(pt->hTheme, resourceId, pszSizeNames->szDisplayName, + ARRAY_SIZE(pszSizeNames->szDisplayName)); + LoadStringW(pt->hTheme, resourceId+1000, pszSizeNames->szTooltip, + ARRAY_SIZE(pszSizeNames->szTooltip)); } else hr = E_PROP_ID_UNSUPPORTED; -- 2.14.4

1 0

[PATCH] user32/tests: Allow newer Win10 behaviour
by André Hentschel 18 Sep '18

18 Sep '18

Signed-off-by: André Hentschel <nerv(a)dawncrow.de> --- dlls/user32/tests/monitor.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/user32/tests/monitor.c b/dlls/user32/tests/monitor.c index f4c1a4b17c..8f1b2c6fdd 100644 --- a/dlls/user32/tests/monitor.c +++ b/dlls/user32/tests/monitor.c @@ -585,7 +585,7 @@ static void test_display_config(void) paths = modes = 100; ret = pGetDisplayConfigBufferSizes(0, &paths, &modes); ok(ret == ERROR_INVALID_PARAMETER || ret == ERROR_NOT_SUPPORTED, "got %d\n", ret); - ok(modes == 0 && paths == 0, "got %u, %u\n", modes, paths); + ok((modes == 0 || modes == 100) && paths == 0, "got %u, %u\n", modes, paths); } START_TEST(monitor) -- 2.17.1

1 0

[PATCH] winex11.drv: Add missing biCompression initialization (Valgrind)
by Sven Baars 18 Sep '18

18 Sep '18

This was previously used uninitialized in bitmapinfoheader_from_user_bitmapinfo Signed-off-by: Sven Baars <sven.wine(a)gmail.com> --- dlls/winex11.drv/window.c | 1 + 1 file changed, 1 insertion(+) diff --git a/dlls/winex11.drv/window.c b/dlls/winex11.drv/window.c index 0a4f118c34..37531d8595 100644 --- a/dlls/winex11.drv/window.c +++ b/dlls/winex11.drv/window.c @@ -545,6 +545,7 @@ static BOOL create_icon_pixmaps( HDC hdc, const ICONINFO *icon, Pixmap *icon_ret info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); info->bmiHeader.biBitCount = 0; + info->bmiHeader.biCompression = BI_RGB; if (!(lines = GetDIBits( hdc, icon->hbmColor, 0, 0, NULL, info, DIB_RGB_COLORS ))) goto failed; if (!(bits.ptr = HeapAlloc( GetProcessHeap(), 0, info->bmiHeader.biSizeImage ))) goto failed; if (!GetDIBits( hdc, icon->hbmColor, 0, lines, bits.ptr, info, DIB_RGB_COLORS )) goto failed; -- 2.17.1

2 2

[PATCH 8/8] dxgi/tests: Add test for swapchain formats.
by Józef Kucia 18 Sep '18

18 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/dxgi/tests/dxgi.c | 100 ++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 99 insertions(+), 1 deletion(-) diff --git a/dlls/dxgi/tests/dxgi.c b/dlls/dxgi/tests/dxgi.c index 376c1ecd6fdf..9ab247254922 100644 --- a/dlls/dxgi/tests/dxgi.c +++ b/dlls/dxgi/tests/dxgi.c @@ -3804,7 +3804,7 @@ static void test_swapchain_backbuffer_index(IUnknown *device, BOOL is_d3d12) { swapchain_desc.SwapEffect = tests[i].swap_effect; expected_hr = is_d3d12 && !tests[i].supported_in_d3d12 ? DXGI_ERROR_INVALID_CALL : S_OK; - hr = IDXGIFactory_CreateSwapChain(factory, (IUnknown *)device, &swapchain_desc, &swapchain); + hr = IDXGIFactory_CreateSwapChain(factory, device, &swapchain_desc, &swapchain); ok(hr == expected_hr, "Got hr %#x, expected %#x.\n", hr, expected_hr); if (FAILED(hr)) continue; @@ -3837,6 +3837,102 @@ done: ok(refcount == !is_d3d12, "Got unexpected refcount %u.\n", refcount); } +static void test_swapchain_formats(IUnknown *device, BOOL is_d3d12) +{ + DXGI_SWAP_CHAIN_DESC swapchain_desc; + IDXGISwapChain *swapchain; + HRESULT hr, expected_hr; + IDXGIFactory *factory; + unsigned int i; + ULONG refcount; + BOOL is_flip; + RECT rect; + BOOL ret; + + static const struct + { + DXGI_FORMAT format; + DXGI_SWAP_EFFECT swap_effect; + BOOL supported; + } + tests[] = + { + {DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_SWAP_EFFECT_DISCARD, TRUE}, + {DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_SWAP_EFFECT_SEQUENTIAL, TRUE}, + {DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL, TRUE}, + {DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_SWAP_EFFECT_FLIP_DISCARD, TRUE}, + {DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, DXGI_SWAP_EFFECT_DISCARD, TRUE}, + {DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, DXGI_SWAP_EFFECT_SEQUENTIAL, TRUE}, + {DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL, FALSE}, + {DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, DXGI_SWAP_EFFECT_FLIP_DISCARD, FALSE}, + {DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_SWAP_EFFECT_DISCARD, TRUE}, + {DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_SWAP_EFFECT_SEQUENTIAL, TRUE}, + {DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL, TRUE}, + {DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_SWAP_EFFECT_FLIP_DISCARD, TRUE}, + {DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, DXGI_SWAP_EFFECT_DISCARD, TRUE}, + {DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, DXGI_SWAP_EFFECT_SEQUENTIAL, TRUE}, + {DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL, FALSE}, + {DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, DXGI_SWAP_EFFECT_FLIP_DISCARD, FALSE}, + {DXGI_FORMAT_R10G10B10A2_UNORM, DXGI_SWAP_EFFECT_DISCARD, TRUE}, + {DXGI_FORMAT_R10G10B10A2_UNORM, DXGI_SWAP_EFFECT_SEQUENTIAL, TRUE}, + {DXGI_FORMAT_R10G10B10A2_UNORM, DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL, TRUE}, + {DXGI_FORMAT_R10G10B10A2_UNORM, DXGI_SWAP_EFFECT_FLIP_DISCARD, TRUE}, + {DXGI_FORMAT_R16G16B16A16_FLOAT, DXGI_SWAP_EFFECT_DISCARD, TRUE}, + {DXGI_FORMAT_R16G16B16A16_FLOAT, DXGI_SWAP_EFFECT_SEQUENTIAL, TRUE}, + {DXGI_FORMAT_R16G16B16A16_FLOAT, DXGI_SWAP_EFFECT_FLIP_DISCARD, TRUE}, + {DXGI_FORMAT_R16G16B16A16_FLOAT, DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL, TRUE}, + {DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM, DXGI_SWAP_EFFECT_FLIP_DISCARD, FALSE}, + {DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM, DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL, FALSE}, + }; + + get_factory(device, is_d3d12, &factory); + + swapchain_desc.BufferDesc.RefreshRate.Numerator = 60; + swapchain_desc.BufferDesc.RefreshRate.Denominator = 60; + swapchain_desc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; + swapchain_desc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; + swapchain_desc.SampleDesc.Count = 1; + swapchain_desc.SampleDesc.Quality = 0; + swapchain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + swapchain_desc.BufferCount = 4; + swapchain_desc.OutputWindow = CreateWindowA("static", "dxgi_test", 0, 0, 0, 400, 200, 0, 0, 0, 0); + swapchain_desc.Windowed = TRUE; + swapchain_desc.Flags = 0; + + ret = GetClientRect(swapchain_desc.OutputWindow, &rect); + ok(ret, "Failed to get client rect.\n"); + swapchain_desc.BufferDesc.Width = rect.right; + swapchain_desc.BufferDesc.Height = rect.bottom; + + for (i = 0; i < ARRAY_SIZE(tests); ++i) + { + is_flip = tests[i].swap_effect == DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL + || tests[i].swap_effect == DXGI_SWAP_EFFECT_FLIP_DISCARD; + + if (is_d3d12 && !is_flip) + continue; + + swapchain_desc.BufferDesc.Format = tests[i].format; + swapchain_desc.SwapEffect = tests[i].swap_effect; + hr = IDXGIFactory_CreateSwapChain(factory, device, &swapchain_desc, &swapchain); + expected_hr = tests[i].supported ? S_OK : DXGI_ERROR_INVALID_CALL; + ok(hr == expected_hr + /* Flip presentation model not supported. */ + || broken(is_flip && hr == DXGI_ERROR_INVALID_CALL), + "Test %u: Got hr %#x, expected %#x.\n", i, hr, expected_hr); + + if (SUCCEEDED(hr)) + { + refcount = IDXGISwapChain_Release(swapchain); + ok(!refcount, "Swapchain has %u references left.\n", refcount); + } + } + + DestroyWindow(swapchain_desc.OutputWindow); + refcount = IDXGIFactory_Release(factory); + ok(refcount == !is_d3d12, "Got unexpected refcount %u.\n", refcount); +} + static void test_maximum_frame_latency(void) { IDXGIDevice1 *device1; @@ -4210,6 +4306,7 @@ START_TEST(dxgi) test_swapchain_parameters(); run_on_d3d10(test_swapchain_resize); run_on_d3d10(test_swapchain_backbuffer_index); + run_on_d3d10(test_swapchain_formats); if (!(d3d12_module = LoadLibraryA("d3d12.dll"))) { @@ -4228,6 +4325,7 @@ START_TEST(dxgi) run_on_d3d12(test_swapchain_resize); run_on_d3d12(test_swapchain_backbuffer_index); + run_on_d3d12(test_swapchain_formats); FreeLibrary(d3d12_module); } -- 2.16.4

2 1

[PATCH 7/8] dxgi: Add support for DXGI_FORMAT_R16G16B16A16_FLOAT D3D12 swapchains.
by Józef Kucia 18 Sep '18

18 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/dxgi/swapchain.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/dlls/dxgi/swapchain.c b/dlls/dxgi/swapchain.c index 680fa54541e0..3eefbe50df85 100644 --- a/dlls/dxgi/swapchain.c +++ b/dlls/dxgi/swapchain.c @@ -989,6 +989,7 @@ static DXGI_FORMAT dxgi_format_from_vk_format(VkFormat vk_format) case VK_FORMAT_B8G8R8A8_UNORM: return DXGI_FORMAT_B8G8R8A8_UNORM; case VK_FORMAT_R8G8B8A8_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; case VK_FORMAT_A2B10G10R10_UNORM_PACK32: return DXGI_FORMAT_R10G10B10A2_UNORM; + case VK_FORMAT_R16G16B16A16_SFLOAT: return DXGI_FORMAT_R16G16B16A16_FLOAT; default: WARN("Unhandled format %#x.\n", vk_format); return DXGI_FORMAT_UNKNOWN; @@ -999,8 +1000,10 @@ static VkFormat get_swapchain_fallback_format(VkFormat vk_format) { switch (vk_format) { - case VK_FORMAT_R8G8B8A8_UNORM: return VK_FORMAT_B8G8R8A8_UNORM; - case VK_FORMAT_A2B10G10R10_UNORM_PACK32: return VK_FORMAT_B8G8R8A8_UNORM; + case VK_FORMAT_R8G8B8A8_UNORM: + case VK_FORMAT_A2B10G10R10_UNORM_PACK32: + case VK_FORMAT_R16G16B16A16_SFLOAT: + return VK_FORMAT_B8G8R8A8_UNORM; default: WARN("Unhandled format %#x.\n", vk_format); return VK_FORMAT_UNDEFINED; -- 2.16.4

2 1

[PATCH 6/8] dxgi: Validate formats for flip presentation model.
by Józef Kucia 18 Sep '18

18 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/dxgi/swapchain.c | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/dlls/dxgi/swapchain.c b/dlls/dxgi/swapchain.c index 5d2cb4aa535a..680fa54541e0 100644 --- a/dlls/dxgi/swapchain.c +++ b/dlls/dxgi/swapchain.c @@ -55,6 +55,21 @@ static DXGI_SWAP_EFFECT dxgi_swap_effect_from_wined3d(enum wined3d_swap_effect s } } +static BOOL dxgi_validate_flip_swap_effect_format(DXGI_FORMAT format) +{ + switch (format) + { + case DXGI_FORMAT_R16G16B16A16_FLOAT: + case DXGI_FORMAT_R10G10B10A2_UNORM: + case DXGI_FORMAT_R8G8B8A8_UNORM: + case DXGI_FORMAT_B8G8R8A8_UNORM: + return TRUE; + default: + WARN("Invalid swapchain format %#x for flip presentation model.\n", format); + return FALSE; + } +} + BOOL dxgi_validate_swapchain_desc(const DXGI_SWAP_CHAIN_DESC1 *desc) { unsigned int min_buffer_count; @@ -70,6 +85,9 @@ BOOL dxgi_validate_swapchain_desc(const DXGI_SWAP_CHAIN_DESC1 *desc) case DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL: min_buffer_count = 2; + if (!dxgi_validate_flip_swap_effect_format(desc->Format)) + return FALSE; + if (desc->SampleDesc.Count != 1 || desc->SampleDesc.Quality) { WARN("Invalid sample desc %u, %u for swap effect %#x.\n", @@ -968,9 +986,7 @@ static DXGI_FORMAT dxgi_format_from_vk_format(VkFormat vk_format) { switch (vk_format) { - case VK_FORMAT_B8G8R8A8_SRGB: return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB; case VK_FORMAT_B8G8R8A8_UNORM: return DXGI_FORMAT_B8G8R8A8_UNORM; - case VK_FORMAT_R8G8B8A8_SRGB: return DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; case VK_FORMAT_R8G8B8A8_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; case VK_FORMAT_A2B10G10R10_UNORM_PACK32: return DXGI_FORMAT_R10G10B10A2_UNORM; default: @@ -983,7 +999,6 @@ static VkFormat get_swapchain_fallback_format(VkFormat vk_format) { switch (vk_format) { - case VK_FORMAT_R8G8B8A8_SRGB: return VK_FORMAT_B8G8R8A8_SRGB; case VK_FORMAT_R8G8B8A8_UNORM: return VK_FORMAT_B8G8R8A8_UNORM; case VK_FORMAT_A2B10G10R10_UNORM_PACK32: return VK_FORMAT_B8G8R8A8_UNORM; default: -- 2.16.4

2 1

[PATCH 5/8] dxgi: Validate swapchain desc in d3d12_swapchain_ResizeBuffers().
by Józef Kucia 18 Sep '18

18 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/dxgi/swapchain.c | 28 +++++++++++++++------------- 1 file changed, 15 insertions(+), 13 deletions(-) diff --git a/dlls/dxgi/swapchain.c b/dlls/dxgi/swapchain.c index 57d6b245c452..5d2cb4aa535a 100644 --- a/dlls/dxgi/swapchain.c +++ b/dlls/dxgi/swapchain.c @@ -1786,7 +1786,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_swapchain_ResizeBuffers(IDXGISwapChain3 * UINT buffer_count, UINT width, UINT height, DXGI_FORMAT format, UINT flags) { struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain3(iface); - DXGI_SWAP_CHAIN_DESC1 *desc; + DXGI_SWAP_CHAIN_DESC1 *desc, new_desc; unsigned int i; ULONG refcount; HRESULT hr; @@ -1808,9 +1808,10 @@ static HRESULT STDMETHODCALLTYPE d3d12_swapchain_ResizeBuffers(IDXGISwapChain3 * } desc = &swapchain->desc; + new_desc = swapchain->desc; - if (!buffer_count) - buffer_count = desc->BufferCount; + if (buffer_count) + new_desc.BufferCount = buffer_count; if (!width || !height) { RECT client_rect; @@ -1826,20 +1827,21 @@ static HRESULT STDMETHODCALLTYPE d3d12_swapchain_ResizeBuffers(IDXGISwapChain3 * if (!height) height = client_rect.bottom; } - if (!format) - format = desc->Format; + new_desc.Width = width; + new_desc.Height = height; - if (desc->Width == width && desc->Height == height - && desc->Format == format && desc->BufferCount == buffer_count) - return S_OK; + if (format) + new_desc.Format = format; - d3d12_swapchain_destroy_buffers(swapchain); + if (!dxgi_validate_swapchain_desc(&new_desc)) + return DXGI_ERROR_INVALID_CALL; - desc->Width = width; - desc->Height = height; - desc->Format = format; - desc->BufferCount = buffer_count; + if (desc->Width == new_desc.Width && desc->Height == new_desc.Height + && desc->Format == new_desc.Format && desc->BufferCount == new_desc.BufferCount) + return S_OK; + d3d12_swapchain_destroy_buffers(swapchain); + swapchain->desc = new_desc; if (FAILED(hr = d3d12_swapchain_create_vulkan_swapchain(swapchain))) { ERR("Failed to recreate Vulkan swapchain, hr %#x.\n", hr); -- 2.16.4

2 1

[PATCH 4/8] dxgi: Factor out dxgi_validate_swapchain_desc().
by Józef Kucia 18 Sep '18

18 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/dxgi/dxgi_private.h | 2 ++ dlls/dxgi/factory.c | 30 +----------------------------- dlls/dxgi/swapchain.c | 37 +++++++++++++++++++++++++++++++++++++ 3 files changed, 40 insertions(+), 29 deletions(-) diff --git a/dlls/dxgi/dxgi_private.h b/dlls/dxgi/dxgi_private.h index 4967bd425f22..f74514f0d326 100644 --- a/dlls/dxgi/dxgi_private.h +++ b/dlls/dxgi/dxgi_private.h @@ -182,6 +182,8 @@ HRESULT d3d12_swapchain_create(IWineDXGIFactory *factory, ID3D12CommandQueue *qu const DXGI_SWAP_CHAIN_DESC1 *swapchain_desc, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC *fullscreen_desc, IDXGISwapChain1 **swapchain) DECLSPEC_HIDDEN; +BOOL dxgi_validate_swapchain_desc(const DXGI_SWAP_CHAIN_DESC1 *desc) DECLSPEC_HIDDEN; + /* IDXGISurface */ struct dxgi_surface { diff --git a/dlls/dxgi/factory.c b/dlls/dxgi/factory.c index cc9075afc223..a4577ae278fa 100644 --- a/dlls/dxgi/factory.c +++ b/dlls/dxgi/factory.c @@ -251,7 +251,6 @@ static HRESULT STDMETHODCALLTYPE dxgi_factory_CreateSwapChainForHwnd(IWineDXGIFa IDXGIOutput *output, IDXGISwapChain1 **swapchain) { ID3D12CommandQueue *command_queue; - unsigned int min_buffer_count; IWineDXGIDevice *dxgi_device; HRESULT hr; @@ -270,35 +269,8 @@ static HRESULT STDMETHODCALLTYPE dxgi_factory_CreateSwapChainForHwnd(IWineDXGIFa return DXGI_ERROR_UNSUPPORTED; } - switch (desc->SwapEffect) - { - case DXGI_SWAP_EFFECT_DISCARD: - case DXGI_SWAP_EFFECT_SEQUENTIAL: - min_buffer_count = 1; - break; - - case DXGI_SWAP_EFFECT_FLIP_DISCARD: - case DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL: - min_buffer_count = 2; - - if (desc->SampleDesc.Count != 1 || desc->SampleDesc.Quality) - { - WARN("Invalid sample desc %u, %u for swap effect %#x.\n", - desc->SampleDesc.Count, desc->SampleDesc.Quality, desc->SwapEffect); - return DXGI_ERROR_INVALID_CALL; - } - break; - - default: - WARN("Invalid swap effect %u used.\n", desc->SwapEffect); - return DXGI_ERROR_INVALID_CALL; - } - - if (desc->BufferCount < min_buffer_count || desc->BufferCount > DXGI_MAX_SWAP_CHAIN_BUFFERS) - { - WARN("BufferCount is %u.\n", desc->BufferCount); + if (!dxgi_validate_swapchain_desc(desc)) return DXGI_ERROR_INVALID_CALL; - } if (output) FIXME("Ignoring output %p.\n", output); diff --git a/dlls/dxgi/swapchain.c b/dlls/dxgi/swapchain.c index f8e4f8078e74..57d6b245c452 100644 --- a/dlls/dxgi/swapchain.c +++ b/dlls/dxgi/swapchain.c @@ -55,6 +55,43 @@ static DXGI_SWAP_EFFECT dxgi_swap_effect_from_wined3d(enum wined3d_swap_effect s } } +BOOL dxgi_validate_swapchain_desc(const DXGI_SWAP_CHAIN_DESC1 *desc) +{ + unsigned int min_buffer_count; + + switch (desc->SwapEffect) + { + case DXGI_SWAP_EFFECT_DISCARD: + case DXGI_SWAP_EFFECT_SEQUENTIAL: + min_buffer_count = 1; + break; + + case DXGI_SWAP_EFFECT_FLIP_DISCARD: + case DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL: + min_buffer_count = 2; + + if (desc->SampleDesc.Count != 1 || desc->SampleDesc.Quality) + { + WARN("Invalid sample desc %u, %u for swap effect %#x.\n", + desc->SampleDesc.Count, desc->SampleDesc.Quality, desc->SwapEffect); + return FALSE; + } + break; + + default: + WARN("Invalid swap effect %u used.\n", desc->SwapEffect); + return FALSE; + } + + if (desc->BufferCount < min_buffer_count || desc->BufferCount > DXGI_MAX_SWAP_CHAIN_BUFFERS) + { + WARN("BufferCount is %u.\n", desc->BufferCount); + return FALSE; + } + + return TRUE; +} + static inline struct d3d11_swapchain *d3d11_swapchain_from_IDXGISwapChain1(IDXGISwapChain1 *iface) { return CONTAINING_RECORD(iface, struct d3d11_swapchain, IDXGISwapChain1_iface); -- 2.16.4

2 1

[PATCH 3/8] d3d11/tests: Add a few more tests for texture formats.
by Józef Kucia 18 Sep '18

18 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/d3d11/tests/d3d11.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c index 94e7a8eeb9cc..3ab2642279f7 100644 --- a/dlls/d3d11/tests/d3d11.c +++ b/dlls/d3d11/tests/d3d11.c @@ -7219,6 +7219,13 @@ static void test_texture(void) 0xffb1c4de, 0xfff0f1f2, 0xfffafdfe, 0xff5a560f, 0xffd5ff00, 0xffc8f99f, 0xffaa00aa, 0xffdd55bb, }; + static const WORD r8g8_data[] = + { + 0x0000, 0xffff, 0x0000, 0x7fff, + 0x0203, 0xff10, 0x0b0c, 0x8000, + 0xc4de, 0xfff0, 0xfdfe, 0x5a6f, + 0xff00, 0xffc8, 0x00aa, 0xdd5b, + }; static const BYTE a8_data[] = { 0x00, 0x10, 0x20, 0x30, @@ -7346,10 +7353,14 @@ static void test_texture(void) {blue_data, 5 * sizeof(*blue_data)}, } }; + static const struct texture r32f_float = {4, 4, 1, 1, DXGI_FORMAT_R32_FLOAT, + {{r32_float, 4 * sizeof(*r32_float)}}}; static const struct texture r32f_typeless = {4, 4, 1, 1, DXGI_FORMAT_R32_TYPELESS, {{r32_float, 4 * sizeof(*r32_float)}}}; static const struct texture r32u_typeless = {4, 4, 1, 1, DXGI_FORMAT_R32_TYPELESS, {{r32_uint, 4 * sizeof(*r32_uint)}}}; + static const struct texture r8g8_snorm = {4, 4, 1, 1, DXGI_FORMAT_R8G8_SNORM, + {{r8g8_data, 4 * sizeof(*r8g8_data)}}}; static const struct texture r9g9b9e5_texture = {4, 4, 1, 1, DXGI_FORMAT_R9G9B9E5_SHAREDEXP, {{r9g9b9e5_data, 4 * sizeof(*r9g9b9e5_data)}}}; static const DWORD red_colors[] = @@ -7436,6 +7447,13 @@ static void test_texture(void) 0x7e7e7e7e, 0x7e7e7e7e, 0x7e7e7e7e, 0x7e808080, 0x7e7e7e7e, 0x7e7f7f7f, 0x7e7f7f7f, 0x7e7f7f7f, }; + static const DWORD snorm_colors[] = + { + 0xff000000, 0xff000000, 0xff000000, 0xff00ff00, + 0xff000406, 0xff000020, 0xff001618, 0xff000000, + 0xff000000, 0xff000000, 0xff000000, 0xff00b5df, + 0xff000000, 0xff000000, 0xff000000, 0xff0000b7, + }; static const DWORD r32f_colors[] = { 0xff000000, 0xff0000ff, 0xff00007f, 0xff00007f, @@ -7605,6 +7623,7 @@ static void test_texture(void) #define BC3_UNORM_SRGB DXGI_FORMAT_BC3_UNORM_SRGB #define R8G8B8A8_UNORM_SRGB DXGI_FORMAT_R8G8B8A8_UNORM_SRGB #define R8G8B8A8_UNORM DXGI_FORMAT_R8G8B8A8_UNORM +#define R8G8_SNORM DXGI_FORMAT_R8G8_SNORM #define R32_FLOAT DXGI_FORMAT_R32_FLOAT #define R32_UINT DXGI_FORMAT_R32_UINT #define FMT_UNKNOWN DXGI_FORMAT_UNKNOWN @@ -7617,6 +7636,8 @@ static void test_texture(void) {&ps_sample, &srgb_typeless, {R8G8B8A8_UNORM_SRGB, TEX_2D, 0, 1}, 0.0f, srgb_colors}, {&ps_sample, &srgb_typeless, {R8G8B8A8_UNORM, TEX_2D, 0, 1}, 0.0f, srgb_data}, {&ps_sample, &r32f_typeless, {R32_FLOAT, TEX_2D, 0, 1}, 0.0f, r32f_colors}, + {&ps_sample, &r32f_float, {R32_FLOAT, TEX_2D, 0, 1}, 0.0f, r32f_colors}, + {&ps_sample, &r8g8_snorm, {R8G8_SNORM, TEX_2D, 0, 1}, 0.0f, snorm_colors}, {&ps_sample, &array_2d_texture, {FMT_UNKNOWN, TEX_2D, 0, 1}, 0.0f, red_colors}, {&ps_sample_2d_array, &array_2d_texture, {FMT_UNKNOWN, TEX_2D_ARRAY, 0, 1, 0, 1}, 0.0f, red_colors}, {&ps_sample_2d_array, &array_2d_texture, {FMT_UNKNOWN, TEX_2D_ARRAY, 0, 1, 1, 1}, 0.0f, green_data}, @@ -7632,6 +7653,7 @@ static void test_texture(void) #undef BC3_UNORM_SRGB #undef R8G8B8A8_UNORM_SRGB #undef R8G8B8A8_UNORM +#undef R8G8_SNORM #undef R32_FLOAT #undef R32_UINT #undef FMT_UNKNOWN -- 2.16.4

2 1

[PATCH 2/8] wined3d: Apply legacy format swizzles only when requested.
by Józef Kucia 18 Sep '18

18 Sep '18

We do not want to apply legacy format swizzles for D3D10+. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- WINED3D_LEGACY_UNBOUND_RESOURCE_COLOR is slightly overloaded. We could rename WINED3D_LEGACY_UNBOUND_RESOURCE_COLOR, but I could not find a very good name. --- dlls/wined3d/utils.c | 77 ++++++++++++++++++++++++++++------------------------ 1 file changed, 42 insertions(+), 35 deletions(-) diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index db27270ba8a0..f1988669ac1a 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -3444,69 +3444,76 @@ static struct color_fixup_desc create_color_fixup_desc_from_string(const char *s static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_gl_info *gl_info) { + const struct wined3d_d3d_info *d3d_info = &adapter->d3d_info; struct wined3d_format *format; + BOOL use_legacy_fixups; unsigned int i; static const struct { enum wined3d_format_id id; const char *fixup; + BOOL legacy; enum wined3d_gl_extension extension; } fixups[] = { - {WINED3DFMT_R16_FLOAT, "X11W", WINED3D_GL_EXT_NONE}, - {WINED3DFMT_R32_FLOAT, "X11W", WINED3D_GL_EXT_NONE}, - {WINED3DFMT_R16G16_UNORM, "XY1W", WINED3D_GL_EXT_NONE}, - {WINED3DFMT_R16G16_FLOAT, "XY1W", WINED3D_GL_EXT_NONE}, - {WINED3DFMT_R32G32_FLOAT, "XY1W", WINED3D_GL_EXT_NONE}, + {WINED3DFMT_R16_FLOAT, "X11W", TRUE, WINED3D_GL_EXT_NONE}, + {WINED3DFMT_R32_FLOAT, "X11W", TRUE, WINED3D_GL_EXT_NONE}, + {WINED3DFMT_R16G16_UNORM, "XY1W", TRUE, WINED3D_GL_EXT_NONE}, + {WINED3DFMT_R16G16_FLOAT, "XY1W", TRUE, WINED3D_GL_EXT_NONE}, + {WINED3DFMT_R32G32_FLOAT, "XY1W", TRUE, WINED3D_GL_EXT_NONE}, - {WINED3DFMT_R8G8_SNORM, "xy11", WINED3D_GL_EXT_NONE}, - {WINED3DFMT_R8G8_SNORM, "XY11", NV_TEXTURE_SHADER}, - {WINED3DFMT_R8G8_SNORM, "XY11", EXT_TEXTURE_SNORM}, + {WINED3DFMT_R8G8_SNORM, "xy11", FALSE, WINED3D_GL_EXT_NONE}, + {WINED3DFMT_R8G8_SNORM, "XY11", TRUE, NV_TEXTURE_SHADER}, + {WINED3DFMT_R8G8_SNORM, "XY11", TRUE, EXT_TEXTURE_SNORM}, - {WINED3DFMT_R16G16_SNORM, "xy11", WINED3D_GL_EXT_NONE}, - {WINED3DFMT_R16G16_SNORM, "XY11", NV_TEXTURE_SHADER}, - {WINED3DFMT_R16G16_SNORM, "XY11", EXT_TEXTURE_SNORM}, + {WINED3DFMT_R16G16_SNORM, "xy11", FALSE, WINED3D_GL_EXT_NONE}, + {WINED3DFMT_R16G16_SNORM, "XY11", TRUE, NV_TEXTURE_SHADER}, + {WINED3DFMT_R16G16_SNORM, "XY11", TRUE, EXT_TEXTURE_SNORM}, - {WINED3DFMT_R8G8B8A8_SNORM, "xyzw", WINED3D_GL_EXT_NONE}, - {WINED3DFMT_R8G8B8A8_SNORM, "XYZW", NV_TEXTURE_SHADER}, - {WINED3DFMT_R8G8B8A8_SNORM, "XYZW", EXT_TEXTURE_SNORM}, + {WINED3DFMT_R8G8B8A8_SNORM, "xyzw", FALSE, WINED3D_GL_EXT_NONE}, + {WINED3DFMT_R8G8B8A8_SNORM, "XYZW", FALSE, NV_TEXTURE_SHADER}, + {WINED3DFMT_R8G8B8A8_SNORM, "XYZW", FALSE, EXT_TEXTURE_SNORM}, - {WINED3DFMT_R5G5_SNORM_L6_UNORM, "xzY1", WINED3D_GL_EXT_NONE}, - {WINED3DFMT_R5G5_SNORM_L6_UNORM, "XYZW", NV_TEXTURE_SHADER}, - {WINED3DFMT_R5G5_SNORM_L6_UNORM, "XYZW", EXT_TEXTURE_SNORM}, + {WINED3DFMT_R5G5_SNORM_L6_UNORM, "xzY1", FALSE, WINED3D_GL_EXT_NONE}, + {WINED3DFMT_R5G5_SNORM_L6_UNORM, "XYZW", FALSE, NV_TEXTURE_SHADER}, + {WINED3DFMT_R5G5_SNORM_L6_UNORM, "XYZW", FALSE, EXT_TEXTURE_SNORM}, - {WINED3DFMT_R8G8_SNORM_L8X8_UNORM, "xyZW", WINED3D_GL_EXT_NONE}, - {WINED3DFMT_R8G8_SNORM_L8X8_UNORM, "XYZW", NV_TEXTURE_SHADER}, + {WINED3DFMT_R8G8_SNORM_L8X8_UNORM, "xyZW", FALSE, WINED3D_GL_EXT_NONE}, + {WINED3DFMT_R8G8_SNORM_L8X8_UNORM, "XYZW", FALSE, NV_TEXTURE_SHADER}, - {WINED3DFMT_ATI1N, "XXXX", EXT_TEXTURE_COMPRESSION_RGTC}, - {WINED3DFMT_ATI1N, "XXXX", ARB_TEXTURE_COMPRESSION_RGTC}, + {WINED3DFMT_ATI1N, "XXXX", FALSE, EXT_TEXTURE_COMPRESSION_RGTC}, + {WINED3DFMT_ATI1N, "XXXX", FALSE, ARB_TEXTURE_COMPRESSION_RGTC}, - {WINED3DFMT_ATI2N, "XW11", ATI_TEXTURE_COMPRESSION_3DC}, - {WINED3DFMT_ATI2N, "YX11", EXT_TEXTURE_COMPRESSION_RGTC}, - {WINED3DFMT_ATI2N, "YX11", ARB_TEXTURE_COMPRESSION_RGTC}, + {WINED3DFMT_ATI2N, "XW11", FALSE, ATI_TEXTURE_COMPRESSION_3DC}, + {WINED3DFMT_ATI2N, "YX11", FALSE, EXT_TEXTURE_COMPRESSION_RGTC}, + {WINED3DFMT_ATI2N, "YX11", FALSE, ARB_TEXTURE_COMPRESSION_RGTC}, - {WINED3DFMT_A8_UNORM, "000X", WINED3D_GL_EXT_NONE}, - {WINED3DFMT_A8_UNORM, "XYZW", WINED3D_GL_LEGACY_CONTEXT}, + {WINED3DFMT_A8_UNORM, "000X", FALSE, WINED3D_GL_EXT_NONE}, + {WINED3DFMT_A8_UNORM, "XYZW", FALSE, WINED3D_GL_LEGACY_CONTEXT}, - {WINED3DFMT_L8A8_UNORM, "XXXY", WINED3D_GL_EXT_NONE}, - {WINED3DFMT_L8A8_UNORM, "XYZW", WINED3D_GL_LEGACY_CONTEXT}, + {WINED3DFMT_L8A8_UNORM, "XXXY", FALSE, WINED3D_GL_EXT_NONE}, + {WINED3DFMT_L8A8_UNORM, "XYZW", FALSE, WINED3D_GL_LEGACY_CONTEXT}, - {WINED3DFMT_L4A4_UNORM, "XXXY", WINED3D_GL_EXT_NONE}, - {WINED3DFMT_L4A4_UNORM, "XYZW", WINED3D_GL_LEGACY_CONTEXT}, + {WINED3DFMT_L4A4_UNORM, "XXXY", FALSE, WINED3D_GL_EXT_NONE}, + {WINED3DFMT_L4A4_UNORM, "XYZW", FALSE, WINED3D_GL_LEGACY_CONTEXT}, - {WINED3DFMT_L16_UNORM, "XXX1", WINED3D_GL_EXT_NONE}, - {WINED3DFMT_L16_UNORM, "XYZW", WINED3D_GL_LEGACY_CONTEXT}, + {WINED3DFMT_L16_UNORM, "XXX1", FALSE, WINED3D_GL_EXT_NONE}, + {WINED3DFMT_L16_UNORM, "XYZW", FALSE, WINED3D_GL_LEGACY_CONTEXT}, - {WINED3DFMT_INTZ, "XXXX", WINED3D_GL_EXT_NONE}, - {WINED3DFMT_INTZ, "XYZW", WINED3D_GL_LEGACY_CONTEXT}, + {WINED3DFMT_INTZ, "XXXX", FALSE, WINED3D_GL_EXT_NONE}, + {WINED3DFMT_INTZ, "XYZW", FALSE, WINED3D_GL_LEGACY_CONTEXT}, - {WINED3DFMT_L8_UNORM, "XXX1", ARB_TEXTURE_RG}, + {WINED3DFMT_L8_UNORM, "XXX1", FALSE, ARB_TEXTURE_RG}, }; + use_legacy_fixups = d3d_info->wined3d_creation_flags & WINED3D_LEGACY_UNBOUND_RESOURCE_COLOR; for (i = 0; i < ARRAY_SIZE(fixups); ++i) { + if (fixups[i].legacy && !use_legacy_fixups) + continue; + if (!gl_info->supported[fixups[i].extension]) continue; -- 2.16.4

2 1

[PATCH 1/8] wined3d: Implement vCoverage register.
by Józef Kucia 18 Sep '18

18 Sep '18

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=45848 Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/glsl_shader.c | 4 ++++ dlls/wined3d/wined3d_private.h | 1 + 2 files changed, 5 insertions(+) diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c index 64c8b77aa385..52348084c388 100644 --- a/dlls/wined3d/glsl_shader.c +++ b/dlls/wined3d/glsl_shader.c @@ -3280,6 +3280,10 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register * string_buffer_sprintf(register_name, "vpc[%u]", reg->idx[0].offset); break; + case WINED3DSPR_COVERAGE: + string_buffer_sprintf(register_name, "gl_SampleMaskIn[0]"); + break; + case WINED3DSPR_SAMPLEMASK: string_buffer_sprintf(register_name, "sample_mask"); break; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index b96d3a53c094..3820cde09892 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -4152,6 +4152,7 @@ static inline BOOL shader_is_scalar(const struct wined3d_shader_register *reg) case WINED3DSPR_OUTPOINTID: case WINED3DSPR_PREDICATE: /* p0 */ case WINED3DSPR_PRIMID: /* primID */ + case WINED3DSPR_COVERAGE: /* vCoverage */ case WINED3DSPR_SAMPLEMASK: /* oMask */ return TRUE; -- 2.16.4

2 1

[PATCH 1/6] quartz/tests: Add some tests for IFilterGraph_EnumFilters().
by Zebediah Figura 18 Sep '18

18 Sep '18

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/quartz/tests/filtergraph.c | 103 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 103 insertions(+) diff --git a/dlls/quartz/tests/filtergraph.c b/dlls/quartz/tests/filtergraph.c index 6a8afb3..c0e5250 100644 --- a/dlls/quartz/tests/filtergraph.c +++ b/dlls/quartz/tests/filtergraph.c @@ -592,6 +592,108 @@ todo_wine DeleteFileW(filename); } +static void test_enum_filters(void) +{ + IBaseFilter *filter1, *filter2, *filters[2]; + IFilterGraph2 *graph = create_graph(); + IEnumFilters *enum1, *enum2; + ULONG count, ref; + HRESULT hr; + + CoCreateInstance(&CLSID_AsyncReader, NULL, CLSCTX_INPROC_SERVER, + &IID_IBaseFilter, (void **)&filter1); + CoCreateInstance(&CLSID_AsyncReader, NULL, CLSCTX_INPROC_SERVER, + &IID_IBaseFilter, (void **)&filter2); + + hr = IFilterGraph2_EnumFilters(graph, &enum1); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Next(enum1, 1, filters, NULL); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + + IFilterGraph2_AddFilter(graph, filter1, NULL); + IFilterGraph2_AddFilter(graph, filter2, NULL); + + hr = IEnumFilters_Next(enum1, 1, filters, NULL); + ok(hr == VFW_E_ENUM_OUT_OF_SYNC, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Reset(enum1); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Next(enum1, 1, filters, NULL); + ok(hr == S_OK, "Got hr %#x.\n", hr); +todo_wine + ok(filters[0] == filter2, "Got filter %p.\n", filters[0]); + IBaseFilter_Release(filters[0]); + + hr = IEnumFilters_Next(enum1, 1, filters, &count); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(count == 1, "Got count %u.\n", count); +todo_wine + ok(filters[0] == filter1, "Got filter %p.\n", filters[0]); + IBaseFilter_Release(filters[0]); + + hr = IEnumFilters_Next(enum1, 1, filters, &count); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + ok(count == 0, "Got count %u.\n", count); + + hr = IEnumFilters_Reset(enum1); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Next(enum1, 2, filters, &count); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(count == 2, "Got count %u.\n", count); +todo_wine { + ok(filters[0] == filter2, "Got filter %p.\n", filters[0]); + ok(filters[1] == filter1, "Got filter %p.\n", filters[1]); +} + IBaseFilter_Release(filters[0]); + IBaseFilter_Release(filters[1]); + + IFilterGraph2_RemoveFilter(graph, filter1); + IFilterGraph2_AddFilter(graph, filter1, NULL); + + hr = IEnumFilters_Next(enum1, 2, filters, &count); + ok(hr == VFW_E_ENUM_OUT_OF_SYNC, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Reset(enum1); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Next(enum1, 2, filters, &count); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(count == 2, "Got count %u.\n", count); +todo_wine { + ok(filters[0] == filter1, "Got filter %p.\n", filters[0]); + ok(filters[1] == filter2, "Got filter %p.\n", filters[1]); +} + IBaseFilter_Release(filters[0]); + IBaseFilter_Release(filters[1]); + + hr = IEnumFilters_Reset(enum1); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Clone(enum1, &enum2); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Skip(enum2, 1); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Next(enum2, 2, filters, &count); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + ok(count == 1, "Got count %u.\n", count); +todo_wine + ok(filters[0] == filter2, "Got filter %p.\n", filters[0]); + IBaseFilter_Release(filters[0]); + + hr = IEnumFilters_Skip(enum1, 3); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + + IEnumFilters_Release(enum2); + IEnumFilters_Release(enum1); + ref = IFilterGraph2_Release(graph); + ok(!ref, "Got outstanding refcount %d.\n", hr); +} + static DWORD WINAPI call_RenderFile_multithread(LPVOID lParam) { WCHAR *filename = load_resource(avifile); @@ -2402,6 +2504,7 @@ START_TEST(filtergraph) test_render_run(avifile); test_render_run(mpegfile); + test_enum_filters(); test_graph_builder(); test_render_filter_priority(); test_aggregate_filter_graph(); -- 2.7.4

2 7

[PATCH v2 1/6] quartz/tests: Add some tests for IFilterGraph_EnumFilters().
by Zebediah Figura 18 Sep '18

18 Sep '18

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/quartz/tests/filtergraph.c | 103 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 103 insertions(+) diff --git a/dlls/quartz/tests/filtergraph.c b/dlls/quartz/tests/filtergraph.c index 6a8afb3..4f1e9cf 100644 --- a/dlls/quartz/tests/filtergraph.c +++ b/dlls/quartz/tests/filtergraph.c @@ -592,6 +592,108 @@ todo_wine DeleteFileW(filename); } +static void test_enum_filters(void) +{ + IBaseFilter *filter1, *filter2, *filters[2]; + IFilterGraph2 *graph = create_graph(); + IEnumFilters *enum1, *enum2; + ULONG count, ref; + HRESULT hr; + + CoCreateInstance(&CLSID_AsyncReader, NULL, CLSCTX_INPROC_SERVER, + &IID_IBaseFilter, (void **)&filter1); + CoCreateInstance(&CLSID_AsyncReader, NULL, CLSCTX_INPROC_SERVER, + &IID_IBaseFilter, (void **)&filter2); + + hr = IFilterGraph2_EnumFilters(graph, &enum1); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Next(enum1, 1, filters, NULL); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + + IFilterGraph2_AddFilter(graph, filter1, NULL); + IFilterGraph2_AddFilter(graph, filter2, NULL); + + hr = IEnumFilters_Next(enum1, 1, filters, NULL); + ok(hr == VFW_E_ENUM_OUT_OF_SYNC, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Reset(enum1); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Next(enum1, 1, filters, NULL); + ok(hr == S_OK, "Got hr %#x.\n", hr); +todo_wine + ok(filters[0] == filter2, "Got filter %p.\n", filters[0]); + IBaseFilter_Release(filters[0]); + + hr = IEnumFilters_Next(enum1, 1, filters, &count); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(count == 1, "Got count %u.\n", count); +todo_wine + ok(filters[0] == filter1, "Got filter %p.\n", filters[0]); + IBaseFilter_Release(filters[0]); + + hr = IEnumFilters_Next(enum1, 1, filters, &count); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + ok(count == 0, "Got count %u.\n", count); + + hr = IEnumFilters_Reset(enum1); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Next(enum1, 2, filters, &count); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(count == 2, "Got count %u.\n", count); +todo_wine { + ok(filters[0] == filter2, "Got filter %p.\n", filters[0]); + ok(filters[1] == filter1, "Got filter %p.\n", filters[1]); +} + IBaseFilter_Release(filters[0]); + IBaseFilter_Release(filters[1]); + + IFilterGraph2_RemoveFilter(graph, filter1); + IFilterGraph2_AddFilter(graph, filter1, NULL); + + hr = IEnumFilters_Next(enum1, 2, filters, &count); + ok(hr == VFW_E_ENUM_OUT_OF_SYNC, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Reset(enum1); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Next(enum1, 2, filters, &count); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(count == 2, "Got count %u.\n", count); +todo_wine { + ok(filters[0] == filter1, "Got filter %p.\n", filters[0]); + ok(filters[1] == filter2, "Got filter %p.\n", filters[1]); +} + IBaseFilter_Release(filters[0]); + IBaseFilter_Release(filters[1]); + + hr = IEnumFilters_Reset(enum1); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Clone(enum1, &enum2); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Skip(enum2, 1); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IEnumFilters_Next(enum2, 2, filters, &count); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + ok(count == 1, "Got count %u.\n", count); +todo_wine + ok(filters[0] == filter2, "Got filter %p.\n", filters[0]); + IBaseFilter_Release(filters[0]); + + hr = IEnumFilters_Skip(enum1, 3); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + + IEnumFilters_Release(enum2); + IEnumFilters_Release(enum1); + ref = IFilterGraph2_Release(graph); + ok(!ref, "Got outstanding refcount %d.\n", ref); +} + static DWORD WINAPI call_RenderFile_multithread(LPVOID lParam) { WCHAR *filename = load_resource(avifile); @@ -2402,6 +2504,7 @@ START_TEST(filtergraph) test_render_run(avifile); test_render_run(mpegfile); + test_enum_filters(); test_graph_builder(); test_render_filter_priority(); test_aggregate_filter_graph(); -- 2.7.4

1 5

[PATCH] msi: Fix a typo.
by Dmitry Timoshkov 18 Sep '18

18 Sep '18

This patch should fix the regresion introduced by baea371c3d4153bc4a718c07f46971d4d39aa9f3. Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msi/package.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/msi/package.c b/dlls/msi/package.c index 3374964078..8e9ae6dd90 100644 --- a/dlls/msi/package.c +++ b/dlls/msi/package.c @@ -1742,7 +1742,7 @@ MSIHANDLE WINAPI MsiGetActiveDatabase(MSIHANDLE hInstall) { __TRY { - handle = remote_GetActiveDatabase(hInstall); + handle = remote_GetActiveDatabase(remote); handle = alloc_msi_remote_handle(handle); } __EXCEPT(rpc_filter) -- 2.17.1

3 4

[PATCH v7 1/7] shell32/autocomplete: Move the autocomplete processing and WM_KEYUP to separate functions
by Gabriel Ivăncescu 18 Sep '18

18 Sep '18

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- v7: Add a space after for/switch. dlls/shell32/autocomplete.c | 336 ++++++++++++++++++++++++-------------------- 1 file changed, 182 insertions(+), 154 deletions(-) diff --git a/dlls/shell32/autocomplete.c b/dlls/shell32/autocomplete.c index 9f35ff7..874d831 100644 --- a/dlls/shell32/autocomplete.c +++ b/dlls/shell32/autocomplete.c @@ -119,6 +119,76 @@ static size_t format_quick_complete(WCHAR *dst, const WCHAR *qc, const WCHAR *st return dst - base; } +static void autocomplete_text(IAutoCompleteImpl *ac, WCHAR *text, UINT len, HWND hwnd, BOOL displayall) +{ + HRESULT hr; + UINT cpt; + + SendMessageW(ac->hwndListBox, LB_RESETCONTENT, 0, 0); + + /* Set txtbackup to point to text itself (which must not be released) */ + heap_free(ac->txtbackup); + ac->txtbackup = text; + + if (!displayall && !len) + return; + + IEnumString_Reset(ac->enumstr); + for (cpt = 0;;) + { + LPOLESTR strs = NULL; + ULONG fetched; + + hr = IEnumString_Next(ac->enumstr, 1, &strs, &fetched); + if (hr != S_OK) + break; + + if (!strncmpiW(text, strs, len)) + { + if (cpt == 0 && (ac->options & ACO_AUTOAPPEND)) + { + WCHAR buffW[255]; + + strcpyW(buffW, text); + strcatW(buffW, &strs[len]); + SetWindowTextW(hwnd, buffW); + SendMessageW(hwnd, EM_SETSEL, len, strlenW(strs)); + if (!(ac->options & ACO_AUTOSUGGEST)) + { + CoTaskMemFree(strs); + break; + } + } + + if (ac->options & ACO_AUTOSUGGEST) + SendMessageW(ac->hwndListBox, LB_ADDSTRING, 0, (LPARAM)strs); + + cpt++; + } + + CoTaskMemFree(strs); + } + + if (ac->options & ACO_AUTOSUGGEST) + { + if (cpt) + { + RECT r; + UINT height = SendMessageW(ac->hwndListBox, LB_GETITEMHEIGHT, 0, 0); + SendMessageW(ac->hwndListBox, LB_CARETOFF, 0, 0); + GetWindowRect(hwnd, &r); + SetParent(ac->hwndListBox, HWND_DESKTOP); + /* It seems that Windows XP displays 7 lines at most + and otherwise displays a vertical scroll bar */ + SetWindowPos(ac->hwndListBox, HWND_TOP, + r.left, r.bottom + 1, r.right - r.left, min(height * 7, height*(cpt+1)), + SWP_SHOWWINDOW ); + } + else + ShowWindow(ac->hwndListBox, SW_HIDE); + } +} + static void destroy_autocomplete_object(IAutoCompleteImpl *ac) { ac->hwndEdit = NULL; @@ -128,17 +198,122 @@ static void destroy_autocomplete_object(IAutoCompleteImpl *ac) } /* + Helper for ACEditSubclassProc +*/ +static LRESULT ACEditSubclassProc_KeyUp(IAutoCompleteImpl *ac, HWND hwnd, UINT uMsg, + WPARAM wParam, LPARAM lParam) +{ + WCHAR *text; + UINT len, size; + BOOL displayall = FALSE; + + len = SendMessageW(hwnd, WM_GETTEXTLENGTH, 0, 0); + size = len + 1; + if (!(text = heap_alloc(size * sizeof(WCHAR)))) + return 0; + len = SendMessageW(hwnd, WM_GETTEXT, size, (LPARAM)text); + + switch (wParam) + { + case VK_RETURN: + /* If quickComplete is set and control is pressed, replace the string */ + if (ac->quickComplete && (GetKeyState(VK_CONTROL) & 0x8000)) + { + WCHAR *buf; + size_t sz = strlenW(ac->quickComplete) + 1 + len; + if ((buf = heap_alloc(sz * sizeof(WCHAR)))) + { + len = format_quick_complete(buf, ac->quickComplete, text, len); + SendMessageW(hwnd, WM_SETTEXT, 0, (LPARAM)buf); + SendMessageW(hwnd, EM_SETSEL, 0, len); + heap_free(buf); + } + } + + if (ac->options & ACO_AUTOSUGGEST) + ShowWindow(ac->hwndListBox, SW_HIDE); + heap_free(text); + return 0; + case VK_LEFT: + case VK_RIGHT: + heap_free(text); + return 0; + case VK_UP: + case VK_DOWN: + /* Two cases here: + - if the listbox is not visible and ACO_UPDOWNKEYDROPSLIST is + set, display it with all the entries, without selecting any + - if the listbox is visible, change the selection + */ + if ( (ac->options & (ACO_AUTOSUGGEST | ACO_UPDOWNKEYDROPSLIST)) + && (!IsWindowVisible(ac->hwndListBox) && (! *text)) ) + { + /* We must display all the entries */ + displayall = TRUE; + } + else + { + INT count, sel; + heap_free(text); + if (!IsWindowVisible(ac->hwndListBox)) + return 0; + + count = SendMessageW(ac->hwndListBox, LB_GETCOUNT, 0, 0); + + /* Change the selection */ + sel = SendMessageW(ac->hwndListBox, LB_GETCURSEL, 0, 0); + if (wParam == VK_UP) + sel = ((sel - 1) < 0) ? count - 1 : sel - 1; + else + sel = ((sel + 1) >= count) ? -1 : sel + 1; + SendMessageW(ac->hwndListBox, LB_SETCURSEL, sel, 0); + if (sel >= 0) + { + WCHAR *msg; + UINT len; + + len = SendMessageW(ac->hwndListBox, LB_GETTEXTLEN, sel, 0); + if (!(msg = heap_alloc((len + 1) * sizeof(WCHAR)))) + return 0; + len = SendMessageW(ac->hwndListBox, LB_GETTEXT, sel, (LPARAM)msg); + SendMessageW(hwnd, WM_SETTEXT, 0, (LPARAM)msg); + SendMessageW(hwnd, EM_SETSEL, len, len); + heap_free(msg); + } + else + { + UINT len; + SendMessageW(hwnd, WM_SETTEXT, 0, (LPARAM)ac->txtbackup); + len = strlenW(ac->txtbackup); + SendMessageW(hwnd, EM_SETSEL, len, len); + } + return 0; + } + break; + case VK_BACK: + case VK_DELETE: + if ((! *text) && (ac->options & ACO_AUTOSUGGEST)) + { + heap_free(text); + ShowWindow(ac->hwndListBox, SW_HIDE); + return CallWindowProcW(ac->wpOrigEditProc, hwnd, uMsg, wParam, lParam); + } + break; + } + + if (len + 1 != size) + text = heap_realloc(text, (len + 1) * sizeof(WCHAR)); + + autocomplete_text(ac, text, len, hwnd, displayall); + return 0; +} + +/* Window procedure for autocompletion */ static LRESULT APIENTRY ACEditSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { IAutoCompleteImpl *This = GetPropW(hwnd, autocomplete_propertyW); - HRESULT hr; - WCHAR *hwndText; - UINT len, size, cpt; - RECT r; - BOOL displayall = FALSE; - int height, sel; if (!This->enabled) return CallWindowProcW(This->wpOrigEditProc, hwnd, uMsg, wParam, lParam); @@ -155,154 +330,7 @@ static LRESULT APIENTRY ACEditSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, } return CallWindowProcW(This->wpOrigEditProc, hwnd, uMsg, wParam, lParam); case WM_KEYUP: - len = SendMessageW(hwnd, WM_GETTEXTLENGTH, 0, 0); - size = len + 1; - if (!(hwndText = heap_alloc(size * sizeof(WCHAR)))) - return 0; - len = SendMessageW(hwnd, WM_GETTEXT, size, (LPARAM)hwndText); - - switch(wParam) { - case VK_RETURN: - /* If quickComplete is set and control is pressed, replace the string */ - if (This->quickComplete && (GetKeyState(VK_CONTROL) & 0x8000)) - { - WCHAR *buf; - size_t sz = strlenW(This->quickComplete) + 1 + len; - if ((buf = heap_alloc(sz * sizeof(WCHAR)))) - { - len = format_quick_complete(buf, This->quickComplete, hwndText, len); - SendMessageW(hwnd, WM_SETTEXT, 0, (LPARAM)buf); - SendMessageW(hwnd, EM_SETSEL, 0, len); - heap_free(buf); - } - } - - if (This->options & ACO_AUTOSUGGEST) - ShowWindow(This->hwndListBox, SW_HIDE); - heap_free(hwndText); - return 0; - case VK_LEFT: - case VK_RIGHT: - heap_free(hwndText); - return 0; - case VK_UP: - case VK_DOWN: - /* Two cases here : - - if the listbox is not visible, displays it - with all the entries if the style ACO_UPDOWNKEYDROPSLIST - is present but does not select anything. - - if the listbox is visible, change the selection - */ - if ( (This->options & (ACO_AUTOSUGGEST | ACO_UPDOWNKEYDROPSLIST)) - && (!IsWindowVisible(This->hwndListBox) && (! *hwndText)) ) - { - /* We must display all the entries */ - displayall = TRUE; - } else { - heap_free(hwndText); - if (IsWindowVisible(This->hwndListBox)) { - int count; - - count = SendMessageW(This->hwndListBox, LB_GETCOUNT, 0, 0); - /* Change the selection */ - sel = SendMessageW(This->hwndListBox, LB_GETCURSEL, 0, 0); - if (wParam == VK_UP) - sel = ((sel-1) < 0) ? count-1 : sel-1; - else - sel = ((sel+1) >= count) ? -1 : sel+1; - SendMessageW(This->hwndListBox, LB_SETCURSEL, sel, 0); - if (sel != -1) { - WCHAR *msg; - int len; - - len = SendMessageW(This->hwndListBox, LB_GETTEXTLEN, sel, 0); - if (!(msg = heap_alloc((len + 1) * sizeof(WCHAR)))) - return 0; - len = SendMessageW(This->hwndListBox, LB_GETTEXT, sel, (LPARAM)msg); - SendMessageW(hwnd, WM_SETTEXT, 0, (LPARAM)msg); - SendMessageW(hwnd, EM_SETSEL, len, len); - heap_free(msg); - } else { - UINT len; - SendMessageW(hwnd, WM_SETTEXT, 0, (LPARAM)This->txtbackup); - len = strlenW(This->txtbackup); - SendMessageW(hwnd, EM_SETSEL, len, len); - } - } - return 0; - } - break; - case VK_BACK: - case VK_DELETE: - if ((! *hwndText) && (This->options & ACO_AUTOSUGGEST)) { - heap_free(hwndText); - ShowWindow(This->hwndListBox, SW_HIDE); - return CallWindowProcW(This->wpOrigEditProc, hwnd, uMsg, wParam, lParam); - } - break; - } - - if (len + 1 != size) - hwndText = heap_realloc(hwndText, (len + 1) * sizeof(WCHAR)); - - SendMessageW(This->hwndListBox, LB_RESETCONTENT, 0, 0); - - /* Set txtbackup to point to hwndText itself (which must not be released) */ - heap_free(This->txtbackup); - This->txtbackup = hwndText; - - if (!displayall && !len) - break; - - IEnumString_Reset(This->enumstr); - for(cpt = 0;;) { - LPOLESTR strs = NULL; - ULONG fetched; - - hr = IEnumString_Next(This->enumstr, 1, &strs, &fetched); - if (hr != S_OK) - break; - - if (!strncmpiW(hwndText, strs, len)) { - if (cpt == 0 && (This->options & ACO_AUTOAPPEND)) { - WCHAR buffW[255]; - - strcpyW(buffW, hwndText); - strcatW(buffW, &strs[len]); - SetWindowTextW(hwnd, buffW); - SendMessageW(hwnd, EM_SETSEL, len, strlenW(strs)); - if (!(This->options & ACO_AUTOSUGGEST)) { - CoTaskMemFree(strs); - break; - } - } - - if (This->options & ACO_AUTOSUGGEST) - SendMessageW(This->hwndListBox, LB_ADDSTRING, 0, (LPARAM)strs); - - cpt++; - } - - CoTaskMemFree(strs); - } - - if (This->options & ACO_AUTOSUGGEST) { - if (cpt) { - height = SendMessageW(This->hwndListBox, LB_GETITEMHEIGHT, 0, 0); - SendMessageW(This->hwndListBox, LB_CARETOFF, 0, 0); - GetWindowRect(hwnd, &r); - SetParent(This->hwndListBox, HWND_DESKTOP); - /* It seems that Windows XP displays 7 lines at most - and otherwise displays a vertical scroll bar */ - SetWindowPos(This->hwndListBox, HWND_TOP, - r.left, r.bottom + 1, r.right - r.left, min(height * 7, height*(cpt+1)), - SWP_SHOWWINDOW ); - } else { - ShowWindow(This->hwndListBox, SW_HIDE); - } - } - - break; + return ACEditSubclassProc_KeyUp(This, hwnd, uMsg, wParam, lParam); case WM_DESTROY: { WNDPROC proc = This->wpOrigEditProc; -- 1.9.1

2 11

[PATCH v3 3/3] comdlg32/tests: Fix failures on newer Windows 10.
by Zhiyi Zhang 18 Sep '18

18 Sep '18

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/comdlg32/tests/itemdlg.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/comdlg32/tests/itemdlg.c b/dlls/comdlg32/tests/itemdlg.c index 6b63063e29..90001b96be 100644 --- a/dlls/comdlg32/tests/itemdlg.c +++ b/dlls/comdlg32/tests/itemdlg.c @@ -1069,7 +1069,7 @@ static void test_advise_helper(IFileDialog *pfd) for(i = 0; i < 10; i++) { hr = IFileDialog_Advise(pfd, pfde, &cookie[i]); ok(hr == S_OK, "got 0x%08x\n", hr); - ok(cookie[i] == i+1, "Got cookie: %d\n", cookie[i]); + ok(cookie[i] == i+cookie[0], "Got cookie: %d\n", cookie[i]); } ok(pfdeimpl->ref == 10+1, "got ref %d\n", pfdeimpl->ref); ensure_zero_events(pfdeimpl); @@ -1102,7 +1102,7 @@ static void test_advise_helper(IFileDialog *pfd) hr = IFileDialog_Advise(pfd, pfde, &cookie[0]); ok(hr == S_OK, "got 0x%08x\n", hr); - todo_wine ok(cookie[0] == 1, "got cookie: %d\n", cookie[0]); + ok(cookie[0] >= 1, "got cookie: %d\n", cookie[0]); ok(pfdeimpl->ref == 1+1, "got ref %d\n", pfdeimpl->ref); ensure_zero_events(pfdeimpl); -- 2.18.0

3 3

[PATCH v3 2/3] comdlg32: Check invalid options in IFileDialog::SetOptions.
by Zhiyi Zhang 18 Sep '18

18 Sep '18

Fix Steam chat unable to select files. Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/comdlg32/itemdlg.c | 10 ++++++++++ dlls/comdlg32/tests/itemdlg.c | 19 +++++++++++++++++++ 2 files changed, 29 insertions(+) diff --git a/dlls/comdlg32/itemdlg.c b/dlls/comdlg32/itemdlg.c index c8eff3438d..ff97ae26d4 100644 --- a/dlls/comdlg32/itemdlg.c +++ b/dlls/comdlg32/itemdlg.c @@ -2505,6 +2505,16 @@ static HRESULT WINAPI IFileDialog2_fnSetOptions(IFileDialog2 *iface, FILEOPENDIA FileDialogImpl *This = impl_from_IFileDialog2(iface); TRACE("%p (0x%x)\n", This, fos); + if (fos & ~(FOS_OVERWRITEPROMPT | FOS_STRICTFILETYPES | FOS_NOCHANGEDIR | FOS_PICKFOLDERS | FOS_FORCEFILESYSTEM + | FOS_ALLNONSTORAGEITEMS | FOS_NOVALIDATE | FOS_ALLOWMULTISELECT | FOS_PATHMUSTEXIST | FOS_FILEMUSTEXIST + | FOS_CREATEPROMPT | FOS_SHAREAWARE | FOS_NOREADONLYRETURN | FOS_NOTESTFILECREATE | FOS_HIDEMRUPLACES + | FOS_HIDEPINNEDPLACES | FOS_NODEREFERENCELINKS | FOS_DONTADDTORECENT | FOS_FORCESHOWHIDDEN + | FOS_DEFAULTNOMINIMODE | FOS_FORCEPREVIEWPANEON | FOS_SUPPORTSTREAMABLEITEMS)) + { + WARN("Invalid option %#x\n", fos); + return E_INVALIDARG; + } + if( !(This->options & FOS_PICKFOLDERS) && (fos & FOS_PICKFOLDERS) ) { WCHAR buf[30]; diff --git a/dlls/comdlg32/tests/itemdlg.c b/dlls/comdlg32/tests/itemdlg.c index d3be8c8d29..6b63063e29 100644 --- a/dlls/comdlg32/tests/itemdlg.c +++ b/dlls/comdlg32/tests/itemdlg.c @@ -536,6 +536,8 @@ static void test_basics(void) const WCHAR fname2[] = {'f','n','a','m','e','2', 0}; const WCHAR fspec2[] = {'*','.','e','x','e',0}; COMDLG_FILTERSPEC filterspec[2] = {{fname1, fspec1}, {fname2, fspec2}}; + const DWORD invalid_fos[] = {0x1, 0x10, 0x400, 0x80000, 0x400000, 0x800000, 0x1000000, 0x4000000, 0x8000000}; + INT i; /* This should work on every platform with IFileDialog */ SHGetDesktopFolder(&psfdesktop); @@ -586,6 +588,23 @@ static void test_basics(void) ok(fdoptions == (FOS_OVERWRITEPROMPT | FOS_NOREADONLYRETURN | FOS_PATHMUSTEXIST | FOS_NOCHANGEDIR), "Unexpected default options: 0x%08x\n", fdoptions); + /* Check SetOptions invalid options handling */ + for (i = 0; i < ARRAY_SIZE(invalid_fos); i++) + { + hr = IFileOpenDialog_SetOptions(pfod, invalid_fos[i]); + ok(hr == E_INVALIDARG, "got 0x%08x.\n", hr); + hr = IFileOpenDialog_GetOptions(pfod, &fdoptions); + ok(hr == S_OK, "got 0x%08x.\n", hr); + ok(fdoptions == (FOS_PATHMUSTEXIST | FOS_FILEMUSTEXIST | FOS_NOCHANGEDIR), "got %08x\n", fdoptions); + + hr = IFileSaveDialog_SetOptions(pfsd, invalid_fos[i]); + ok(hr == E_INVALIDARG, "got 0x%08x.\n", hr); + hr = IFileSaveDialog_GetOptions(pfsd, &fdoptions); + ok(hr == S_OK, "got 0x%08x.\n", hr); + ok(fdoptions == (FOS_OVERWRITEPROMPT | FOS_NOREADONLYRETURN | FOS_PATHMUSTEXIST | FOS_NOCHANGEDIR), + "got %08x\n", fdoptions); + } + /* GetResult */ hr = IFileOpenDialog_GetResult(pfod, NULL); ok(hr == E_INVALIDARG, "got 0x%08x.\n", hr); -- 2.18.0

2 1

[PATCH v3 1/3] comdlg32/tests: Fix crashes.
by Zhiyi Zhang 18 Sep '18

18 Sep '18

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- Supersede 150805,150806,150807 dlls/comdlg32/tests/itemdlg.c | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/dlls/comdlg32/tests/itemdlg.c b/dlls/comdlg32/tests/itemdlg.c index d28e682b49..d3be8c8d29 100644 --- a/dlls/comdlg32/tests/itemdlg.c +++ b/dlls/comdlg32/tests/itemdlg.c @@ -1032,10 +1032,14 @@ static void test_advise_helper(IFileDialog *pfd) pfde = IFileDialogEvents_Constructor(); pfdeimpl = impl_from_IFileDialogEvents(pfde); - hr = IFileDialog_Advise(pfd, NULL, NULL); - ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); - hr = IFileDialog_Advise(pfd, pfde, NULL); - ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); + /* Null pointer tests crashed on Windows 10 16299 or newer */ + if (0) + { + hr = IFileDialog_Advise(pfd, NULL, NULL); + ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); + hr = IFileDialog_Advise(pfd, pfde, NULL); + ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); + } hr = IFileDialog_Advise(pfd, NULL, &cookie[0]); ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); ok(pfdeimpl->ref == 1, "got ref %d\n", pfdeimpl->ref); -- 2.18.0

2 1

[v2 PATCH 1/3] d2d1: Update to ID2D1BitmapBrush1.
by Nikolay Sivov 18 Sep '18

18 Sep '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/d2d1/brush.c | 134 ++++++++++++++++++++++++++++----------- dlls/d2d1/d2d1_private.h | 2 +- dlls/d2d1/tests/d2d1.c | 44 +++++++++++++ 3 files changed, 142 insertions(+), 38 deletions(-) diff --git a/dlls/d2d1/brush.c b/dlls/d2d1/brush.c index 450507cef6..fa4488ef18 100644 --- a/dlls/d2d1/brush.c +++ b/dlls/d2d1/brush.c @@ -816,22 +816,23 @@ HRESULT d2d_radial_gradient_brush_create(ID2D1Factory *factory, return S_OK; } -static inline struct d2d_brush *impl_from_ID2D1BitmapBrush(ID2D1BitmapBrush *iface) +static inline struct d2d_brush *impl_from_ID2D1BitmapBrush1(ID2D1BitmapBrush1 *iface) { return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface); } -static HRESULT STDMETHODCALLTYPE d2d_bitmap_brush_QueryInterface(ID2D1BitmapBrush *iface, +static HRESULT STDMETHODCALLTYPE d2d_bitmap_brush_QueryInterface(ID2D1BitmapBrush1 *iface, REFIID iid, void **out) { TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out); - if (IsEqualGUID(iid, &IID_ID2D1BitmapBrush) + if (IsEqualGUID(iid, &IID_ID2D1BitmapBrush1) + || IsEqualGUID(iid, &IID_ID2D1BitmapBrush) || IsEqualGUID(iid, &IID_ID2D1Brush) || IsEqualGUID(iid, &IID_ID2D1Resource) || IsEqualGUID(iid, &IID_IUnknown)) { - ID2D1BitmapBrush_AddRef(iface); + ID2D1BitmapBrush1_AddRef(iface); *out = iface; return S_OK; } @@ -842,9 +843,9 @@ static HRESULT STDMETHODCALLTYPE d2d_bitmap_brush_QueryInterface(ID2D1BitmapBrus return E_NOINTERFACE; } -static ULONG STDMETHODCALLTYPE d2d_bitmap_brush_AddRef(ID2D1BitmapBrush *iface) +static ULONG STDMETHODCALLTYPE d2d_bitmap_brush_AddRef(ID2D1BitmapBrush1 *iface) { - struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface); + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); ULONG refcount = InterlockedIncrement(&brush->refcount); TRACE("%p increasing refcount to %u.\n", iface, refcount); @@ -852,9 +853,9 @@ static ULONG STDMETHODCALLTYPE d2d_bitmap_brush_AddRef(ID2D1BitmapBrush *iface) return refcount; } -static ULONG STDMETHODCALLTYPE d2d_bitmap_brush_Release(ID2D1BitmapBrush *iface) +static ULONG STDMETHODCALLTYPE d2d_bitmap_brush_Release(ID2D1BitmapBrush1 *iface) { - struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface); + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); ULONG refcount = InterlockedDecrement(&brush->refcount); TRACE("%p decreasing refcount to %u.\n", iface, refcount); @@ -871,57 +872,57 @@ static ULONG STDMETHODCALLTYPE d2d_bitmap_brush_Release(ID2D1BitmapBrush *iface) return refcount; } -static void STDMETHODCALLTYPE d2d_bitmap_brush_GetFactory(ID2D1BitmapBrush *iface, +static void STDMETHODCALLTYPE d2d_bitmap_brush_GetFactory(ID2D1BitmapBrush1 *iface, ID2D1Factory **factory) { - struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface); + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); TRACE("iface %p, factory %p.\n", iface, factory); ID2D1Factory_AddRef(*factory = brush->factory); } -static void STDMETHODCALLTYPE d2d_bitmap_brush_SetOpacity(ID2D1BitmapBrush *iface, float opacity) +static void STDMETHODCALLTYPE d2d_bitmap_brush_SetOpacity(ID2D1BitmapBrush1 *iface, float opacity) { - struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface); + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); TRACE("iface %p, opacity %.8e.\n", iface, opacity); brush->opacity = opacity; } -static void STDMETHODCALLTYPE d2d_bitmap_brush_SetTransform(ID2D1BitmapBrush *iface, +static void STDMETHODCALLTYPE d2d_bitmap_brush_SetTransform(ID2D1BitmapBrush1 *iface, const D2D1_MATRIX_3X2_F *transform) { - struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface); + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); TRACE("iface %p, transform %p.\n", iface, transform); brush->transform = *transform; } -static float STDMETHODCALLTYPE d2d_bitmap_brush_GetOpacity(ID2D1BitmapBrush *iface) +static float STDMETHODCALLTYPE d2d_bitmap_brush_GetOpacity(ID2D1BitmapBrush1 *iface) { - struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface); + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); TRACE("iface %p.\n", iface); return brush->opacity; } -static void STDMETHODCALLTYPE d2d_bitmap_brush_GetTransform(ID2D1BitmapBrush *iface, +static void STDMETHODCALLTYPE d2d_bitmap_brush_GetTransform(ID2D1BitmapBrush1 *iface, D2D1_MATRIX_3X2_F *transform) { - struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface); + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); TRACE("iface %p, transform %p.\n", iface, transform); *transform = brush->transform; } -static void STDMETHODCALLTYPE d2d_bitmap_brush_SetExtendModeX(ID2D1BitmapBrush *iface, D2D1_EXTEND_MODE mode) +static void STDMETHODCALLTYPE d2d_bitmap_brush_SetExtendModeX(ID2D1BitmapBrush1 *iface, D2D1_EXTEND_MODE mode) { - struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface); + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); TRACE("iface %p, mode %#x.\n", iface, mode); @@ -933,9 +934,9 @@ static void STDMETHODCALLTYPE d2d_bitmap_brush_SetExtendModeX(ID2D1BitmapBrush * } } -static void STDMETHODCALLTYPE d2d_bitmap_brush_SetExtendModeY(ID2D1BitmapBrush *iface, D2D1_EXTEND_MODE mode) +static void STDMETHODCALLTYPE d2d_bitmap_brush_SetExtendModeY(ID2D1BitmapBrush1 *iface, D2D1_EXTEND_MODE mode) { - struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface); + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); TRACE("iface %p, mode %#x.\n", iface, mode); @@ -947,13 +948,23 @@ static void STDMETHODCALLTYPE d2d_bitmap_brush_SetExtendModeY(ID2D1BitmapBrush * } } -static void STDMETHODCALLTYPE d2d_bitmap_brush_SetInterpolationMode(ID2D1BitmapBrush *iface, +static void STDMETHODCALLTYPE d2d_bitmap_brush_SetInterpolationMode(ID2D1BitmapBrush1 *iface, D2D1_BITMAP_INTERPOLATION_MODE mode) { - struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface); + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); TRACE("iface %p, mode %#x.\n", iface, mode); + switch (mode) + { + case D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR: + case D2D1_BITMAP_INTERPOLATION_MODE_LINEAR: + break; + default: + WARN("Unknown interpolation mode %#x.\n", mode); + return; + } + brush->u.bitmap.interpolation_mode = mode; if (brush->u.bitmap.sampler_state) { @@ -962,9 +973,9 @@ static void STDMETHODCALLTYPE d2d_bitmap_brush_SetInterpolationMode(ID2D1BitmapB } } -static void STDMETHODCALLTYPE d2d_bitmap_brush_SetBitmap(ID2D1BitmapBrush *iface, ID2D1Bitmap *bitmap) +static void STDMETHODCALLTYPE d2d_bitmap_brush_SetBitmap(ID2D1BitmapBrush1 *iface, ID2D1Bitmap *bitmap) { - struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface); + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); TRACE("iface %p, bitmap %p.\n", iface, bitmap); @@ -975,36 +986,43 @@ static void STDMETHODCALLTYPE d2d_bitmap_brush_SetBitmap(ID2D1BitmapBrush *iface brush->u.bitmap.bitmap = unsafe_impl_from_ID2D1Bitmap(bitmap); } -static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetExtendModeX(ID2D1BitmapBrush *iface) +static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetExtendModeX(ID2D1BitmapBrush1 *iface) { - struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface); + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); TRACE("iface %p.\n", iface); return brush->u.bitmap.extend_mode_x; } -static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetExtendModeY(ID2D1BitmapBrush *iface) +static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetExtendModeY(ID2D1BitmapBrush1 *iface) { - struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface); + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); TRACE("iface %p.\n", iface); return brush->u.bitmap.extend_mode_y; } -static D2D1_BITMAP_INTERPOLATION_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetInterpolationMode(ID2D1BitmapBrush *iface) +static D2D1_BITMAP_INTERPOLATION_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetInterpolationMode(ID2D1BitmapBrush1 *iface) { - struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface); + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); TRACE("iface %p.\n", iface); - return brush->u.bitmap.interpolation_mode; + switch (brush->u.bitmap.interpolation_mode) + { + case D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR: + case D2D1_INTERPOLATION_MODE_LINEAR: + return brush->u.bitmap.interpolation_mode; + default: + return D2D1_BITMAP_INTERPOLATION_MODE_LINEAR; + } } -static void STDMETHODCALLTYPE d2d_bitmap_brush_GetBitmap(ID2D1BitmapBrush *iface, ID2D1Bitmap **bitmap) +static void STDMETHODCALLTYPE d2d_bitmap_brush_GetBitmap(ID2D1BitmapBrush1 *iface, ID2D1Bitmap **bitmap) { - struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface); + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); TRACE("iface %p, bitmap %p.\n", iface, bitmap); @@ -1012,7 +1030,47 @@ static void STDMETHODCALLTYPE d2d_bitmap_brush_GetBitmap(ID2D1BitmapBrush *iface ID2D1Bitmap_AddRef(*bitmap); } -static const struct ID2D1BitmapBrushVtbl d2d_bitmap_brush_vtbl = +static void STDMETHODCALLTYPE d2d_bitmap_brush_SetInterpolationMode1(ID2D1BitmapBrush1 *iface, + D2D1_INTERPOLATION_MODE mode) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + + TRACE("iface %p, mode %#x.\n", iface, mode); + + switch (mode) + { + case D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR: + case D2D1_INTERPOLATION_MODE_LINEAR: + break; + case D2D1_INTERPOLATION_MODE_CUBIC: + case D2D1_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR: + case D2D1_INTERPOLATION_MODE_ANISOTROPIC: + case D2D1_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC: + FIXME("Unhandled interpolation mode %#x.\n", mode); + break; + default: + WARN("Unknown interpolation mode %#x.\n", mode); + return; + } + + brush->u.bitmap.interpolation_mode = mode; + if (brush->u.bitmap.sampler_state) + { + ID3D10SamplerState_Release(brush->u.bitmap.sampler_state); + brush->u.bitmap.sampler_state = NULL; + } +} + +static D2D1_INTERPOLATION_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetInterpolationMode1(ID2D1BitmapBrush1 *iface) +{ + struct d2d_brush *brush = impl_from_ID2D1BitmapBrush1(iface); + + TRACE("iface %p.\n", iface); + + return brush->u.bitmap.interpolation_mode; +} + +static const struct ID2D1BitmapBrush1Vtbl d2d_bitmap_brush_vtbl = { d2d_bitmap_brush_QueryInterface, d2d_bitmap_brush_AddRef, @@ -1030,6 +1088,8 @@ static const struct ID2D1BitmapBrushVtbl d2d_bitmap_brush_vtbl = d2d_bitmap_brush_GetExtendModeY, d2d_bitmap_brush_GetInterpolationMode, d2d_bitmap_brush_GetBitmap, + d2d_bitmap_brush_SetInterpolationMode1, + d2d_bitmap_brush_GetInterpolationMode1, }; HRESULT d2d_bitmap_brush_create(ID2D1Factory *factory, ID2D1Bitmap *bitmap, const D2D1_BITMAP_BRUSH_PROPERTIES *bitmap_brush_desc, @@ -1242,7 +1302,7 @@ static void d2d_brush_bind_bitmap(struct d2d_brush *brush, ID3D10Device *device, { D3D10_SAMPLER_DESC sampler_desc; - if (brush->u.bitmap.interpolation_mode == D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR) + if (brush->u.bitmap.interpolation_mode == D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR) sampler_desc.Filter = D3D10_FILTER_MIN_MAG_MIP_POINT; else sampler_desc.Filter = D3D10_FILTER_MIN_MAG_MIP_LINEAR; diff --git a/dlls/d2d1/d2d1_private.h b/dlls/d2d1/d2d1_private.h index 3fed59fa72..c8515eaa12 100644 --- a/dlls/d2d1/d2d1_private.h +++ b/dlls/d2d1/d2d1_private.h @@ -280,7 +280,7 @@ struct d2d_brush struct d2d_bitmap *bitmap; D2D1_EXTEND_MODE extend_mode_x; D2D1_EXTEND_MODE extend_mode_y; - D2D1_BITMAP_INTERPOLATION_MODE interpolation_mode; + D2D1_INTERPOLATION_MODE interpolation_mode; ID3D10SamplerState *sampler_state; } bitmap; } u; diff --git a/dlls/d2d1/tests/d2d1.c b/dlls/d2d1/tests/d2d1.c index 6419df23d8..4136b69885 100644 --- a/dlls/d2d1/tests/d2d1.c +++ b/dlls/d2d1/tests/d2d1.c @@ -1656,6 +1656,7 @@ static void test_bitmap_brush(void) D2D1_RECT_F src_rect, dst_rect; D2D1_EXTEND_MODE extend_mode; IDXGISwapChain *swapchain; + ID2D1BitmapBrush1 *brush1; ID2D1BitmapBrush *brush; ID2D1RenderTarget *rt; ID3D10Device1 *device; @@ -1877,6 +1878,49 @@ static void test_bitmap_brush(void) match = compare_surface(surface, "cf7b90ba7b139fdfbe9347e1907d635cfb4ed197"); ok(match, "Surface does not match.\n"); + if (SUCCEEDED(ID2D1BitmapBrush_QueryInterface(brush, &IID_ID2D1BitmapBrush1, (void **)&brush1))) + { + D2D1_INTERPOLATION_MODE interpolation_mode1; + + interpolation_mode = ID2D1BitmapBrush1_GetInterpolationMode(brush1); + ok(interpolation_mode == D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR, + "Unexpected interpolation mode %#x.\n", interpolation_mode); + + interpolation_mode1 = ID2D1BitmapBrush1_GetInterpolationMode1(brush1); + ok(interpolation_mode1 == D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR, + "Unexpected interpolation mode %#x.\n", interpolation_mode1); + + ID2D1BitmapBrush1_SetInterpolationMode1(brush1, D2D1_INTERPOLATION_MODE_CUBIC); + interpolation_mode = ID2D1BitmapBrush1_GetInterpolationMode(brush1); + ok(interpolation_mode == D2D1_BITMAP_INTERPOLATION_MODE_LINEAR, + "Unexpected interpolation mode %#x.\n", interpolation_mode); + + interpolation_mode1 = ID2D1BitmapBrush1_GetInterpolationMode1(brush1); + ok(interpolation_mode1 == D2D1_INTERPOLATION_MODE_CUBIC, + "Unexpected interpolation mode %#x.\n", interpolation_mode1); + + ID2D1BitmapBrush1_SetInterpolationMode1(brush1, 100); + interpolation_mode1 = ID2D1BitmapBrush1_GetInterpolationMode1(brush1); + ok(interpolation_mode1 == D2D1_INTERPOLATION_MODE_CUBIC, + "Unexpected interpolation mode %#x.\n", interpolation_mode1); + + ID2D1BitmapBrush1_SetInterpolationMode(brush1, 100); + interpolation_mode1 = ID2D1BitmapBrush1_GetInterpolationMode1(brush1); + ok(interpolation_mode1 == D2D1_INTERPOLATION_MODE_CUBIC, + "Unexpected interpolation mode %#x.\n", interpolation_mode1); + + ID2D1BitmapBrush1_SetInterpolationMode(brush1, D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR); + interpolation_mode = ID2D1BitmapBrush1_GetInterpolationMode(brush1); + ok(interpolation_mode == D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR, + "Unexpected interpolation mode %#x.\n", interpolation_mode); + + interpolation_mode1 = ID2D1BitmapBrush1_GetInterpolationMode1(brush1); + ok(interpolation_mode1 == D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR, + "Unexpected interpolation mode %#x.\n", interpolation_mode1); + + ID2D1BitmapBrush1_Release(brush1); + } + ID2D1BitmapBrush_Release(brush); refcount = ID2D1Bitmap_Release(bitmap); ok(!refcount, "Bitmap has %u references left.\n", refcount); -- 2.18.0

2 5

[PATCH] wininet/tests: Don't check certificate when secure flag is not set
by André Hentschel 18 Sep '18

18 Sep '18

Signed-off-by: André Hentschel <nerv(a)dawncrow.de> --- dlls/wininet/tests/http.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/dlls/wininet/tests/http.c b/dlls/wininet/tests/http.c index ace8512399..8bc06b9166 100644 --- a/dlls/wininet/tests/http.c +++ b/dlls/wininet/tests/http.c @@ -6025,7 +6025,8 @@ static void test_secure_connection(void) ok(ret, "InternetQueryOption failed: %d\n", GetLastError()); ok(flags & SECURITY_FLAG_SECURE, "expected secure flag to be set\n"); - test_cert_struct(req, &test_winehq_org_cert); + if (flags & SECURITY_FLAG_SECURE) + test_cert_struct(req, &test_winehq_org_cert); /* Querying the same option through InternetQueryOptionW still results in * ASCII strings being returned. -- 2.17.1

3 4

[PATCH] dsound: Dont trace current thread ID
by Alistair Leslie-Hughes 18 Sep '18

18 Sep '18

TID is always displayed in output now. Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/dsound/buffer.c | 2 +- dlls/dsound/capture.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/dsound/buffer.c b/dlls/dsound/buffer.c index 1cdc388..cb7ff78 100644 --- a/dlls/dsound/buffer.c +++ b/dlls/dsound/buffer.c @@ -415,7 +415,7 @@ static HRESULT WINAPI IDirectSoundBufferImpl_GetStatus(IDirectSoundBuffer8 *ifac { IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer8(iface); - TRACE("(%p,%p), thread is %04x\n",This,status,GetCurrentThreadId()); + TRACE("(%p,%p)\n",This,status); if (status == NULL) { WARN("invalid parameter: status = NULL\n"); diff --git a/dlls/dsound/capture.c b/dlls/dsound/capture.c index fcc363d..c849624 100644 --- a/dlls/dsound/capture.c +++ b/dlls/dsound/capture.c @@ -386,7 +386,7 @@ static HRESULT WINAPI IDirectSoundCaptureBufferImpl_GetStatus(IDirectSoundCaptur { IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundCaptureBuffer8(iface); - TRACE( "(%p, %p), thread is %04x\n", This, lpdwStatus, GetCurrentThreadId() ); + TRACE( "(%p, %p)\n", This, lpdwStatus ); if (This->device == NULL) { WARN("invalid parameter: This->device == NULL\n"); -- 1.9.1

2 1

[PATCH] user32/tests: Mark newer Win10 behaviour as broken
by André Hentschel 18 Sep '18

18 Sep '18

Signed-off-by: André Hentschel <nerv(a)dawncrow.de> --- dlls/user32/tests/monitor.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/user32/tests/monitor.c b/dlls/user32/tests/monitor.c index f4c1a4b17c..8ba6cc267b 100644 --- a/dlls/user32/tests/monitor.c +++ b/dlls/user32/tests/monitor.c @@ -585,7 +585,7 @@ static void test_display_config(void) paths = modes = 100; ret = pGetDisplayConfigBufferSizes(0, &paths, &modes); ok(ret == ERROR_INVALID_PARAMETER || ret == ERROR_NOT_SUPPORTED, "got %d\n", ret); - ok(modes == 0 && paths == 0, "got %u, %u\n", modes, paths); + ok((modes == 0 || broken(modes == 100)) && paths == 0, "got %u, %u\n", modes, paths); } START_TEST(monitor) -- 2.17.1

2 2

[PATCH v6 1/6] shell32/autocomplete: Move the autocomplete processing and WM_KEYUP to separate functions
by Gabriel Ivăncescu 18 Sep '18

18 Sep '18

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- v6: Also move WM_KEYUP to a separate function. dlls/shell32/autocomplete.c | 336 ++++++++++++++++++++++++-------------------- 1 file changed, 182 insertions(+), 154 deletions(-) diff --git a/dlls/shell32/autocomplete.c b/dlls/shell32/autocomplete.c index 9f35ff7..ebbb9ee 100644 --- a/dlls/shell32/autocomplete.c +++ b/dlls/shell32/autocomplete.c @@ -119,6 +119,76 @@ static size_t format_quick_complete(WCHAR *dst, const WCHAR *qc, const WCHAR *st return dst - base; } +static void autocomplete_text(IAutoCompleteImpl *ac, WCHAR *text, UINT len, HWND hwnd, BOOL displayall) +{ + HRESULT hr; + UINT cpt; + + SendMessageW(ac->hwndListBox, LB_RESETCONTENT, 0, 0); + + /* Set txtbackup to point to text itself (which must not be released) */ + heap_free(ac->txtbackup); + ac->txtbackup = text; + + if (!displayall && !len) + return; + + IEnumString_Reset(ac->enumstr); + for(cpt = 0;;) + { + LPOLESTR strs = NULL; + ULONG fetched; + + hr = IEnumString_Next(ac->enumstr, 1, &strs, &fetched); + if (hr != S_OK) + break; + + if (!strncmpiW(text, strs, len)) + { + if (cpt == 0 && (ac->options & ACO_AUTOAPPEND)) + { + WCHAR buffW[255]; + + strcpyW(buffW, text); + strcatW(buffW, &strs[len]); + SetWindowTextW(hwnd, buffW); + SendMessageW(hwnd, EM_SETSEL, len, strlenW(strs)); + if (!(ac->options & ACO_AUTOSUGGEST)) + { + CoTaskMemFree(strs); + break; + } + } + + if (ac->options & ACO_AUTOSUGGEST) + SendMessageW(ac->hwndListBox, LB_ADDSTRING, 0, (LPARAM)strs); + + cpt++; + } + + CoTaskMemFree(strs); + } + + if (ac->options & ACO_AUTOSUGGEST) + { + if (cpt) + { + RECT r; + UINT height = SendMessageW(ac->hwndListBox, LB_GETITEMHEIGHT, 0, 0); + SendMessageW(ac->hwndListBox, LB_CARETOFF, 0, 0); + GetWindowRect(hwnd, &r); + SetParent(ac->hwndListBox, HWND_DESKTOP); + /* It seems that Windows XP displays 7 lines at most + and otherwise displays a vertical scroll bar */ + SetWindowPos(ac->hwndListBox, HWND_TOP, + r.left, r.bottom + 1, r.right - r.left, min(height * 7, height*(cpt+1)), + SWP_SHOWWINDOW ); + } + else + ShowWindow(ac->hwndListBox, SW_HIDE); + } +} + static void destroy_autocomplete_object(IAutoCompleteImpl *ac) { ac->hwndEdit = NULL; @@ -128,17 +198,122 @@ static void destroy_autocomplete_object(IAutoCompleteImpl *ac) } /* + Helper for ACEditSubclassProc +*/ +static LRESULT ACEditSubclassProc_KeyUp(IAutoCompleteImpl *ac, HWND hwnd, UINT uMsg, + WPARAM wParam, LPARAM lParam) +{ + WCHAR *text; + UINT len, size; + BOOL displayall = FALSE; + + len = SendMessageW(hwnd, WM_GETTEXTLENGTH, 0, 0); + size = len + 1; + if (!(text = heap_alloc(size * sizeof(WCHAR)))) + return 0; + len = SendMessageW(hwnd, WM_GETTEXT, size, (LPARAM)text); + + switch(wParam) + { + case VK_RETURN: + /* If quickComplete is set and control is pressed, replace the string */ + if (ac->quickComplete && (GetKeyState(VK_CONTROL) & 0x8000)) + { + WCHAR *buf; + size_t sz = strlenW(ac->quickComplete) + 1 + len; + if ((buf = heap_alloc(sz * sizeof(WCHAR)))) + { + len = format_quick_complete(buf, ac->quickComplete, text, len); + SendMessageW(hwnd, WM_SETTEXT, 0, (LPARAM)buf); + SendMessageW(hwnd, EM_SETSEL, 0, len); + heap_free(buf); + } + } + + if (ac->options & ACO_AUTOSUGGEST) + ShowWindow(ac->hwndListBox, SW_HIDE); + heap_free(text); + return 0; + case VK_LEFT: + case VK_RIGHT: + heap_free(text); + return 0; + case VK_UP: + case VK_DOWN: + /* Two cases here: + - if the listbox is not visible and ACO_UPDOWNKEYDROPSLIST is + set, display it with all the entries, without selecting any + - if the listbox is visible, change the selection + */ + if ( (ac->options & (ACO_AUTOSUGGEST | ACO_UPDOWNKEYDROPSLIST)) + && (!IsWindowVisible(ac->hwndListBox) && (! *text)) ) + { + /* We must display all the entries */ + displayall = TRUE; + } + else + { + INT count, sel; + heap_free(text); + if (!IsWindowVisible(ac->hwndListBox)) + return 0; + + count = SendMessageW(ac->hwndListBox, LB_GETCOUNT, 0, 0); + + /* Change the selection */ + sel = SendMessageW(ac->hwndListBox, LB_GETCURSEL, 0, 0); + if (wParam == VK_UP) + sel = ((sel - 1) < 0) ? count - 1 : sel - 1; + else + sel = ((sel + 1) >= count) ? -1 : sel + 1; + SendMessageW(ac->hwndListBox, LB_SETCURSEL, sel, 0); + if (sel >= 0) + { + WCHAR *msg; + UINT len; + + len = SendMessageW(ac->hwndListBox, LB_GETTEXTLEN, sel, 0); + if (!(msg = heap_alloc((len + 1) * sizeof(WCHAR)))) + return 0; + len = SendMessageW(ac->hwndListBox, LB_GETTEXT, sel, (LPARAM)msg); + SendMessageW(hwnd, WM_SETTEXT, 0, (LPARAM)msg); + SendMessageW(hwnd, EM_SETSEL, len, len); + heap_free(msg); + } + else + { + UINT len; + SendMessageW(hwnd, WM_SETTEXT, 0, (LPARAM)ac->txtbackup); + len = strlenW(ac->txtbackup); + SendMessageW(hwnd, EM_SETSEL, len, len); + } + return 0; + } + break; + case VK_BACK: + case VK_DELETE: + if ((! *text) && (ac->options & ACO_AUTOSUGGEST)) + { + heap_free(text); + ShowWindow(ac->hwndListBox, SW_HIDE); + return CallWindowProcW(ac->wpOrigEditProc, hwnd, uMsg, wParam, lParam); + } + break; + } + + if (len + 1 != size) + text = heap_realloc(text, (len + 1) * sizeof(WCHAR)); + + autocomplete_text(ac, text, len, hwnd, displayall); + return 0; +} + +/* Window procedure for autocompletion */ static LRESULT APIENTRY ACEditSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { IAutoCompleteImpl *This = GetPropW(hwnd, autocomplete_propertyW); - HRESULT hr; - WCHAR *hwndText; - UINT len, size, cpt; - RECT r; - BOOL displayall = FALSE; - int height, sel; if (!This->enabled) return CallWindowProcW(This->wpOrigEditProc, hwnd, uMsg, wParam, lParam); @@ -155,154 +330,7 @@ static LRESULT APIENTRY ACEditSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, } return CallWindowProcW(This->wpOrigEditProc, hwnd, uMsg, wParam, lParam); case WM_KEYUP: - len = SendMessageW(hwnd, WM_GETTEXTLENGTH, 0, 0); - size = len + 1; - if (!(hwndText = heap_alloc(size * sizeof(WCHAR)))) - return 0; - len = SendMessageW(hwnd, WM_GETTEXT, size, (LPARAM)hwndText); - - switch(wParam) { - case VK_RETURN: - /* If quickComplete is set and control is pressed, replace the string */ - if (This->quickComplete && (GetKeyState(VK_CONTROL) & 0x8000)) - { - WCHAR *buf; - size_t sz = strlenW(This->quickComplete) + 1 + len; - if ((buf = heap_alloc(sz * sizeof(WCHAR)))) - { - len = format_quick_complete(buf, This->quickComplete, hwndText, len); - SendMessageW(hwnd, WM_SETTEXT, 0, (LPARAM)buf); - SendMessageW(hwnd, EM_SETSEL, 0, len); - heap_free(buf); - } - } - - if (This->options & ACO_AUTOSUGGEST) - ShowWindow(This->hwndListBox, SW_HIDE); - heap_free(hwndText); - return 0; - case VK_LEFT: - case VK_RIGHT: - heap_free(hwndText); - return 0; - case VK_UP: - case VK_DOWN: - /* Two cases here : - - if the listbox is not visible, displays it - with all the entries if the style ACO_UPDOWNKEYDROPSLIST - is present but does not select anything. - - if the listbox is visible, change the selection - */ - if ( (This->options & (ACO_AUTOSUGGEST | ACO_UPDOWNKEYDROPSLIST)) - && (!IsWindowVisible(This->hwndListBox) && (! *hwndText)) ) - { - /* We must display all the entries */ - displayall = TRUE; - } else { - heap_free(hwndText); - if (IsWindowVisible(This->hwndListBox)) { - int count; - - count = SendMessageW(This->hwndListBox, LB_GETCOUNT, 0, 0); - /* Change the selection */ - sel = SendMessageW(This->hwndListBox, LB_GETCURSEL, 0, 0); - if (wParam == VK_UP) - sel = ((sel-1) < 0) ? count-1 : sel-1; - else - sel = ((sel+1) >= count) ? -1 : sel+1; - SendMessageW(This->hwndListBox, LB_SETCURSEL, sel, 0); - if (sel != -1) { - WCHAR *msg; - int len; - - len = SendMessageW(This->hwndListBox, LB_GETTEXTLEN, sel, 0); - if (!(msg = heap_alloc((len + 1) * sizeof(WCHAR)))) - return 0; - len = SendMessageW(This->hwndListBox, LB_GETTEXT, sel, (LPARAM)msg); - SendMessageW(hwnd, WM_SETTEXT, 0, (LPARAM)msg); - SendMessageW(hwnd, EM_SETSEL, len, len); - heap_free(msg); - } else { - UINT len; - SendMessageW(hwnd, WM_SETTEXT, 0, (LPARAM)This->txtbackup); - len = strlenW(This->txtbackup); - SendMessageW(hwnd, EM_SETSEL, len, len); - } - } - return 0; - } - break; - case VK_BACK: - case VK_DELETE: - if ((! *hwndText) && (This->options & ACO_AUTOSUGGEST)) { - heap_free(hwndText); - ShowWindow(This->hwndListBox, SW_HIDE); - return CallWindowProcW(This->wpOrigEditProc, hwnd, uMsg, wParam, lParam); - } - break; - } - - if (len + 1 != size) - hwndText = heap_realloc(hwndText, (len + 1) * sizeof(WCHAR)); - - SendMessageW(This->hwndListBox, LB_RESETCONTENT, 0, 0); - - /* Set txtbackup to point to hwndText itself (which must not be released) */ - heap_free(This->txtbackup); - This->txtbackup = hwndText; - - if (!displayall && !len) - break; - - IEnumString_Reset(This->enumstr); - for(cpt = 0;;) { - LPOLESTR strs = NULL; - ULONG fetched; - - hr = IEnumString_Next(This->enumstr, 1, &strs, &fetched); - if (hr != S_OK) - break; - - if (!strncmpiW(hwndText, strs, len)) { - if (cpt == 0 && (This->options & ACO_AUTOAPPEND)) { - WCHAR buffW[255]; - - strcpyW(buffW, hwndText); - strcatW(buffW, &strs[len]); - SetWindowTextW(hwnd, buffW); - SendMessageW(hwnd, EM_SETSEL, len, strlenW(strs)); - if (!(This->options & ACO_AUTOSUGGEST)) { - CoTaskMemFree(strs); - break; - } - } - - if (This->options & ACO_AUTOSUGGEST) - SendMessageW(This->hwndListBox, LB_ADDSTRING, 0, (LPARAM)strs); - - cpt++; - } - - CoTaskMemFree(strs); - } - - if (This->options & ACO_AUTOSUGGEST) { - if (cpt) { - height = SendMessageW(This->hwndListBox, LB_GETITEMHEIGHT, 0, 0); - SendMessageW(This->hwndListBox, LB_CARETOFF, 0, 0); - GetWindowRect(hwnd, &r); - SetParent(This->hwndListBox, HWND_DESKTOP); - /* It seems that Windows XP displays 7 lines at most - and otherwise displays a vertical scroll bar */ - SetWindowPos(This->hwndListBox, HWND_TOP, - r.left, r.bottom + 1, r.right - r.left, min(height * 7, height*(cpt+1)), - SWP_SHOWWINDOW ); - } else { - ShowWindow(This->hwndListBox, SW_HIDE); - } - } - - break; + return ACEditSubclassProc_KeyUp(This, hwnd, uMsg, wParam, lParam); case WM_DESTROY: { WNDPROC proc = This->wpOrigEditProc; -- 1.9.1

2 10

[PATCH] opcservices/tests: Fix copy-pasted copyright line.
by Nikolay Sivov 18 Sep '18

18 Sep '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/opcservices/tests/opcservices.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/dlls/opcservices/tests/opcservices.c b/dlls/opcservices/tests/opcservices.c index bed59405d6..779d17f6c5 100644 --- a/dlls/opcservices/tests/opcservices.c +++ b/dlls/opcservices/tests/opcservices.c @@ -1,8 +1,7 @@ /* - * Font related tests + * OPC Services tests * - * Copyright 2012, 2014-2017 Nikolay Sivov for CodeWeavers - * Copyright 2014 Aric Stewart for CodeWeavers + * Copyright 2018 Nikolay Sivov for CodeWeavers * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public -- 2.18.0

1 0

[PATCH] urlmon/uri: Implement IsEqual for external implementations.
by Nikolay Sivov 18 Sep '18

18 Sep '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/opcservices/tests/opcservices.c | 3 +-- dlls/urlmon/uri.c | 18 ++++++++++++++++-- 2 files changed, 17 insertions(+), 4 deletions(-) diff --git a/dlls/opcservices/tests/opcservices.c b/dlls/opcservices/tests/opcservices.c index 936e2c751d..cfd11491ee 100644 --- a/dlls/opcservices/tests/opcservices.c +++ b/dlls/opcservices/tests/opcservices.c @@ -531,10 +531,9 @@ static void test_rel_part_uri(void) ok(SUCCEEDED(hr), "Failed to get source uri, hr %#x.\n", hr); ok(source_uri != source_uri2, "Unexpected instance.\n"); hr = IOpcUri_IsEqual(source_uri, (IUri *)source_uri2, &ret); - todo_wine { ok(SUCCEEDED(hr), "IsEqual failed, hr %#x.\n", hr); ok(ret, "Expected equal uris.\n"); - } + hr = IOpcUri_QueryInterface(source_uri, &IID_IOpcPartUri, (void **)&unk); ok(hr == (is_root ? E_NOINTERFACE : S_OK), "Unexpected hr %#x, %s.\n", hr, rel_part_uri_tests[i].uri); if (unk) diff --git a/dlls/urlmon/uri.c b/dlls/urlmon/uri.c index 92978dc53f..20a7c1a5f3 100644 --- a/dlls/urlmon/uri.c +++ b/dlls/urlmon/uri.c @@ -5017,8 +5017,22 @@ static HRESULT WINAPI Uri_IsEqual(IUri *iface, IUri *pUri, BOOL *pfEqual) /* Try to convert it to a Uri (allows for a more simple comparison). */ if(!(other = get_uri_obj(pUri))) { - FIXME("(%p)->(%p %p) No support for unknown IUri's yet.\n", iface, pUri, pfEqual); - return E_NOTIMPL; + IUri *other_uri; + HRESULT hr; + BSTR raw; + + hr = IUri_GetRawUri(pUri, &raw); + if (FAILED(hr)) + return hr; + + hr = CreateUri(raw, Uri_CREATE_ALLOW_RELATIVE, 0, &other_uri); + SysFreeString(raw); + if (FAILED(hr)) + return hr; + + hr = Uri_IsEqual(iface, other_uri, pfEqual); + IUri_Release(other_uri); + return hr; } TRACE("comparing to %s\n", debugstr_w(other->canon_uri)); -- 2.18.0

2 2

[v2 PATCH] urlmon/uri: Implement IsEqual for external implementations.
by Nikolay Sivov 18 Sep '18

18 Sep '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- v2: now with urlmon tests. dlls/opcservices/tests/opcservices.c | 3 +- dlls/urlmon/tests/uri.c | 240 +++++++++++++++++++++++++++ dlls/urlmon/uri.c | 18 +- 3 files changed, 257 insertions(+), 4 deletions(-) diff --git a/dlls/opcservices/tests/opcservices.c b/dlls/opcservices/tests/opcservices.c index 936e2c751d..cfd11491ee 100644 --- a/dlls/opcservices/tests/opcservices.c +++ b/dlls/opcservices/tests/opcservices.c @@ -531,10 +531,9 @@ static void test_rel_part_uri(void) ok(SUCCEEDED(hr), "Failed to get source uri, hr %#x.\n", hr); ok(source_uri != source_uri2, "Unexpected instance.\n"); hr = IOpcUri_IsEqual(source_uri, (IUri *)source_uri2, &ret); - todo_wine { ok(SUCCEEDED(hr), "IsEqual failed, hr %#x.\n", hr); ok(ret, "Expected equal uris.\n"); - } + hr = IOpcUri_QueryInterface(source_uri, &IID_IOpcPartUri, (void **)&unk); ok(hr == (is_root ? E_NOINTERFACE : S_OK), "Unexpected hr %#x, %s.\n", hr, rel_part_uri_tests[i].uri); if (unk) diff --git a/dlls/urlmon/tests/uri.c b/dlls/urlmon/tests/uri.c index 7580a1302d..2af3a29458 100644 --- a/dlls/urlmon/tests/uri.c +++ b/dlls/urlmon/tests/uri.c @@ -8515,7 +8515,225 @@ static void test_IUri_HasProperty(void) { } } +struct custom_uri { + IUri IUri_iface; + IUri *uri; +}; + +static inline struct custom_uri* impl_from_IUri(IUri *iface) +{ + return CONTAINING_RECORD(iface, struct custom_uri, IUri_iface); +} + +static HRESULT WINAPI custom_uri_QueryInterface(IUri *iface, REFIID iid, void **out) +{ + if (IsEqualIID(iid, &IID_IUri) || IsEqualIID(iid, &IID_IUnknown)) + { + *out = iface; + IUri_AddRef(iface); + return S_OK; + } + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI custom_uri_AddRef(IUri *iface) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_AddRef(uri->uri); +} + +static ULONG WINAPI custom_uri_Release(IUri *iface) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_Release(uri->uri); +} + +static HRESULT WINAPI custom_uri_GetPropertyBSTR(IUri *iface, Uri_PROPERTY property, BSTR *value, DWORD flags) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetPropertyBSTR(uri->uri, property, value, flags); +} + +static HRESULT WINAPI custom_uri_GetPropertyLength(IUri *iface, Uri_PROPERTY property, DWORD *length, DWORD flags) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetPropertyLength(uri->uri, property, length, flags); +} + +static HRESULT WINAPI custom_uri_GetPropertyDWORD(IUri *iface, Uri_PROPERTY property, DWORD *value, DWORD flags) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetPropertyDWORD(uri->uri, property, value, flags); +} + +static HRESULT WINAPI custom_uri_HasProperty(IUri *iface, Uri_PROPERTY property, BOOL *has_property) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_HasProperty(uri->uri, property, has_property); +} + +static HRESULT WINAPI custom_uri_GetAbsoluteUri(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetAuthority(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetDisplayUri(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetDomain(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetExtension(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetFragment(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetHost(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetPassword(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetPath(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetPathAndQuery(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetQuery(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetRawUri(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetAbsoluteUri(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetSchemeName(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetSchemeName(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetUserInfo(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetUserInfo(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetUserName(IUri *iface, BSTR *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetUserName(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetHostType(IUri *iface, DWORD *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetHostType(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetPort(IUri *iface, DWORD *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetPort(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetScheme(IUri *iface, DWORD *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetScheme(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetZone(IUri *iface, DWORD *value) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetZone(uri->uri, value); +} + +static HRESULT WINAPI custom_uri_GetProperties(IUri *iface, DWORD *flags) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_GetProperties(uri->uri, flags); +} + +static HRESULT WINAPI custom_uri_IsEqual(IUri *iface, IUri *pUri, BOOL *is_equal) +{ + struct custom_uri *uri = impl_from_IUri(iface); + return IUri_IsEqual(uri->uri, pUri, is_equal); +} + +static const IUriVtbl custom_uri_vtbl = +{ + custom_uri_QueryInterface, + custom_uri_AddRef, + custom_uri_Release, + custom_uri_GetPropertyBSTR, + custom_uri_GetPropertyLength, + custom_uri_GetPropertyDWORD, + custom_uri_HasProperty, + custom_uri_GetAbsoluteUri, + custom_uri_GetAuthority, + custom_uri_GetDisplayUri, + custom_uri_GetDomain, + custom_uri_GetExtension, + custom_uri_GetFragment, + custom_uri_GetHost, + custom_uri_GetPassword, + custom_uri_GetPath, + custom_uri_GetPathAndQuery, + custom_uri_GetQuery, + custom_uri_GetRawUri, + custom_uri_GetSchemeName, + custom_uri_GetUserInfo, + custom_uri_GetUserName, + custom_uri_GetHostType, + custom_uri_GetPort, + custom_uri_GetScheme, + custom_uri_GetZone, + custom_uri_GetProperties, + custom_uri_IsEqual, +}; + static void test_IUri_IsEqual(void) { + struct custom_uri custom_uri; IUri *uriA, *uriB; BOOL equal; HRESULT hres; @@ -8537,9 +8755,21 @@ static void test_IUri_IsEqual(void) { hres = IUri_IsEqual(uriA, uriB, NULL); ok(hres == E_POINTER, "Error: IsEqual returned 0x%08x, expected 0x%08x.\n", hres, E_POINTER); + equal = FALSE; + hres = IUri_IsEqual(uriA, uriA, &equal); + ok(hres == S_OK, "Error: IsEqual returned 0x%08x, expected 0x%08x.\n", hres, S_OK); + ok(equal, "Error: Expected equal URIs.\n"); + + equal = FALSE; + hres = IUri_IsEqual(uriA, uriB, &equal); + ok(hres == S_OK, "Error: IsEqual returned 0x%08x, expected 0x%08x.\n", hres, S_OK); + ok(equal, "Error: Expected equal URIs.\n"); + IUri_Release(uriA); IUri_Release(uriB); + custom_uri.IUri_iface.lpVtbl = &custom_uri_vtbl; + for(i = 0; i < ARRAY_SIZE(equality_tests); ++i) { uri_equality test = equality_tests[i]; LPWSTR uriA_W, uriB_W; @@ -8561,6 +8791,16 @@ static void test_IUri_IsEqual(void) { ok(hres == S_OK, "Error: IsEqual returned 0x%08x, expected 0x%08x on equality_tests[%d].\n", hres, S_OK, i); ok(equal == test.equal, "Error: Expected the comparison to be %d on equality_tests[%d].\n", test.equal, i); } + + custom_uri.uri = uriB; + + equal = -1; + hres = IUri_IsEqual(uriA, &custom_uri.IUri_iface, &equal); + todo_wine_if(test.todo) { + ok(hres == S_OK, "Error: IsEqual returned 0x%08x, expected 0x%08x on equality_tests[%d].\n", hres, S_OK, i); + ok(equal == test.equal, "Error: Expected the comparison to be %d on equality_tests[%d].\n", test.equal, i); + } + if(uriA) IUri_Release(uriA); if(uriB) IUri_Release(uriB); diff --git a/dlls/urlmon/uri.c b/dlls/urlmon/uri.c index 92978dc53f..20a7c1a5f3 100644 --- a/dlls/urlmon/uri.c +++ b/dlls/urlmon/uri.c @@ -5017,8 +5017,22 @@ static HRESULT WINAPI Uri_IsEqual(IUri *iface, IUri *pUri, BOOL *pfEqual) /* Try to convert it to a Uri (allows for a more simple comparison). */ if(!(other = get_uri_obj(pUri))) { - FIXME("(%p)->(%p %p) No support for unknown IUri's yet.\n", iface, pUri, pfEqual); - return E_NOTIMPL; + IUri *other_uri; + HRESULT hr; + BSTR raw; + + hr = IUri_GetRawUri(pUri, &raw); + if (FAILED(hr)) + return hr; + + hr = CreateUri(raw, Uri_CREATE_ALLOW_RELATIVE, 0, &other_uri); + SysFreeString(raw); + if (FAILED(hr)) + return hr; + + hr = Uri_IsEqual(iface, other_uri, pfEqual); + IUri_Release(other_uri); + return hr; } TRACE("comparing to %s\n", debugstr_w(other->canon_uri)); -- 2.18.0

1 0

[PATCH 7/7] wsdapi: Prefer Wine version.
by Owen Rudge 18 Sep '18

18 Sep '18

Signed-off-by: Owen Rudge <orudge(a)codeweavers.com> --- dlls/wsdapi/main.c | 2 -- 1 file changed, 2 deletions(-)

1 0

[PATCH 6/7] wsdapi: Don't include null character at the end of sent messages.
by Owen Rudge 18 Sep '18

18 Sep '18

Signed-off-by: Owen Rudge <orudge(a)codeweavers.com> --- dlls/wsdapi/soap.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)

1 0

[PATCH 5/7] wsdapi: Send Probe Matches message via UDP unicast.
by Owen Rudge 18 Sep '18

18 Sep '18

Signed-off-by: Owen Rudge <orudge(a)codeweavers.com> --- dlls/wsdapi/network.c | 32 ++++++++++++++++++++++++++++++++ dlls/wsdapi/soap.c | 4 ++-- dlls/wsdapi/tests/discovery.c | 22 +++++++++++----------- dlls/wsdapi/wsdapi_internal.h | 1 + 4 files changed, 46 insertions(+), 13 deletions(-)

1 0

[PATCH 4/7] wsdapi: Implement generation of ProbeMatches message.
by Owen Rudge 18 Sep '18

18 Sep '18

Signed-off-by: Owen Rudge <orudge(a)codeweavers.com> --- dlls/wsdapi/soap.c | 169 +++++++++++++++++++++++++++++++++- dlls/wsdapi/tests/discovery.c | 2 +- 2 files changed, 169 insertions(+), 2 deletions(-)

1 0

[PATCH 3/7] wsdapi: Implement matching of names in MatchProbeEx.
by Owen Rudge 18 Sep '18

18 Sep '18

Signed-off-by: Owen Rudge <orudge(a)codeweavers.com> --- dlls/wsdapi/discovery.c | 58 ++++++++++++++++++++++++++++++++--- dlls/wsdapi/soap.c | 9 ++++++ dlls/wsdapi/wsdapi_internal.h | 6 ++++ 3 files changed, 69 insertions(+), 4 deletions(-)

1 0

[PATCH 2/7] wsdapi: Ignore duplicate messages.
by Owen Rudge 18 Sep '18

18 Sep '18

Signed-off-by: Owen Rudge <orudge(a)codeweavers.com> --- dlls/wsdapi/discovery.c | 12 +++++++++ dlls/wsdapi/network.c | 2 +- dlls/wsdapi/soap.c | 47 ++++++++++++++++++++++++++++++++++- dlls/wsdapi/wsdapi_internal.h | 11 +++++++- 4 files changed, 69 insertions(+), 3 deletions(-)

1 0

[PATCH 1/7] wsdapi: Use slim reader/writer lock instead of critical section.
by Owen Rudge 18 Sep '18

18 Sep '18

Signed-off-by: Owen Rudge <orudge(a)codeweavers.com> --- dlls/wsdapi/discovery.c | 13 ++++++------- dlls/wsdapi/network.c | 4 ++-- dlls/wsdapi/wsdapi_internal.h | 2 +- 3 files changed, 9 insertions(+), 10 deletions(-)

1 0

[PATCH 2/8] wsdapi/tests: Add test for duplicate message filtering.
by Owen Rudge 18 Sep '18

18 Sep '18

Signed-off-by: Owen Rudge <orudge(a)codeweavers.com> --- dlls/wsdapi/tests/discovery.c | 134 ++++++++++++++++++++++++++++++++-- 1 file changed, 129 insertions(+), 5 deletions(-)

3 5

[PATCH resend] oleaut32: Add DECLSPEC_HOTPATCH to functions patched by MS Word 2010
by Alex Henrie 18 Sep '18

18 Sep '18

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=45199 Signed-off-by: Alex Henrie <alexhenrie24(a)gmail.com> --- dlls/oleaut32/oleaut.c | 2 +- dlls/oleaut32/variant.c | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/dlls/oleaut32/oleaut.c b/dlls/oleaut32/oleaut.c index 20e8d73318..ae3bda668b 100644 --- a/dlls/oleaut32/oleaut.c +++ b/dlls/oleaut32/oleaut.c @@ -270,7 +270,7 @@ static inline IMalloc *get_malloc(void) * See BSTR. * str may be NULL, in which case this function does nothing. */ -void WINAPI SysFreeString(BSTR str) +void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str) { bstr_cache_entry_t *cache_entry; bstr_t *bstr; diff --git a/dlls/oleaut32/variant.c b/dlls/oleaut32/variant.c index 1fa2a6d6fa..8781f3eaed 100644 --- a/dlls/oleaut32/variant.c +++ b/dlls/oleaut32/variant.c @@ -648,7 +648,7 @@ HRESULT VARIANT_ClearInd(VARIANTARG *pVarg) * Success: S_OK. Any previous value in pVarg is freed and its type is set to VT_EMPTY. * Failure: DISP_E_BADVARTYPE, if the variant is not a valid variant type. */ -HRESULT WINAPI VariantClear(VARIANTARG* pVarg) +HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG* pVarg) { HRESULT hres; @@ -962,8 +962,8 @@ VariantCopyInd_Return: * The LCID used for the conversion is LOCALE_USER_DEFAULT. * See VariantChangeTypeEx. */ -HRESULT WINAPI VariantChangeType(VARIANTARG* pvargDest, VARIANTARG* pvargSrc, - USHORT wFlags, VARTYPE vt) +HRESULT WINAPI DECLSPEC_HOTPATCH VariantChangeType(VARIANTARG* pvargDest, VARIANTARG* pvargSrc, + USHORT wFlags, VARTYPE vt) { return VariantChangeTypeEx( pvargDest, pvargSrc, LOCALE_USER_DEFAULT, wFlags, vt ); } -- 2.19.0

1 0

[PATCH resend] ntdll: Add DECLSPEC_HOTPATCH to functions patched by libtcmalloc
by Alex Henrie 18 Sep '18

18 Sep '18

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=45199 Signed-off-by: Alex Henrie <alexhenrie24(a)gmail.com> --- dlls/ntdll/heap.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/ntdll/heap.c b/dlls/ntdll/heap.c index 44d49bca99..bdadc7932d 100644 --- a/dlls/ntdll/heap.c +++ b/dlls/ntdll/heap.c @@ -1662,7 +1662,7 @@ HANDLE WINAPI RtlDestroyHeap( HANDLE heap ) * NOTES * This call does not SetLastError(). */ -PVOID WINAPI RtlAllocateHeap( HANDLE heap, ULONG flags, SIZE_T size ) +void * WINAPI DECLSPEC_HOTPATCH RtlAllocateHeap( HANDLE heap, ULONG flags, SIZE_T size ) { ARENA_FREE *pArena; ARENA_INUSE *pInUse; @@ -1747,7 +1747,7 @@ PVOID WINAPI RtlAllocateHeap( HANDLE heap, ULONG flags, SIZE_T size ) * Success: TRUE, if ptr is NULL or was freed successfully. * Failure: FALSE. */ -BOOLEAN WINAPI RtlFreeHeap( HANDLE heap, ULONG flags, PVOID ptr ) +BOOLEAN WINAPI DECLSPEC_HOTPATCH RtlFreeHeap( HANDLE heap, ULONG flags, void *ptr ) { ARENA_INUSE *pInUse; SUBHEAP *subheap; -- 2.19.0

1 0

[PATCH resend] kernel32: Add DECLSPEC_HOTPATCH to functions patched by libtcmalloc
by Alex Henrie 18 Sep '18

18 Sep '18

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=45199 Signed-off-by: Alex Henrie <alexhenrie24(a)gmail.com> --- dlls/kernel32/virtual.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/kernel32/virtual.c b/dlls/kernel32/virtual.c index c7a15cdcbb..3362868ba0 100644 --- a/dlls/kernel32/virtual.c +++ b/dlls/kernel32/virtual.c @@ -314,7 +314,7 @@ SIZE_T WINAPI VirtualQueryEx( HANDLE process, LPCVOID addr, * Success: Starting address of mapped view. * Failure: NULL. */ -LPVOID WINAPI DECLSPEC_HOTPATCH MapViewOfFile( HANDLE mapping, DWORD access, +void * WINAPI DECLSPEC_HOTPATCH MapViewOfFile( HANDLE mapping, DWORD access, DWORD offset_high, DWORD offset_low, SIZE_T count ) { return MapViewOfFileEx( mapping, access, offset_high, @@ -384,7 +384,7 @@ LPVOID WINAPI MapViewOfFileEx( HANDLE handle, DWORD access, * Failure: FALSE. * */ -BOOL WINAPI UnmapViewOfFile( LPCVOID addr ) +BOOL WINAPI DECLSPEC_HOTPATCH UnmapViewOfFile( const void *addr ) { NTSTATUS status; -- 2.19.0

1 0

[PATCH 4/4] wined3d: Store the NPOT texture capabilities in struct wined3d_d3d_info.
by Henri Verbeet 17 Sep '18

17 Sep '18

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/adapter_gl.c | 8 ++++++-- dlls/wined3d/directx.c | 20 ++++++++------------ dlls/wined3d/resource.c | 3 ++- dlls/wined3d/texture.c | 12 +++++++----- dlls/wined3d/wined3d_private.h | 14 ++++++++------ 5 files changed, 31 insertions(+), 26 deletions(-) diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index f3862cd32c3..e60383cce3b 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -3664,7 +3664,7 @@ static BOOL wined3d_adapter_init_gl_caps(struct wined3d_adapter *adapter, d3d_info->limits.vs_uniform_count = shader_caps.vs_uniform_count; d3d_info->limits.ps_uniform_count = shader_caps.ps_uniform_count; d3d_info->limits.varying_count = shader_caps.varying_count; - d3d_info->shader_double_precision = shader_caps.wined3d_caps & WINED3D_SHADER_CAP_DOUBLE_PRECISION; + d3d_info->shader_double_precision = !!(shader_caps.wined3d_caps & WINED3D_SHADER_CAP_DOUBLE_PRECISION); adapter->vertex_pipe->vp_get_caps(gl_info, &vertex_caps); d3d_info->xyzrhw = vertex_caps.xyzrhw; @@ -3676,10 +3676,14 @@ static BOOL wined3d_adapter_init_gl_caps(struct wined3d_adapter *adapter, adapter->fragment_pipe->get_caps(gl_info, &fragment_caps); d3d_info->limits.ffp_blend_stages = fragment_caps.MaxTextureBlendStages; d3d_info->limits.ffp_textures = fragment_caps.MaxSimultaneousTextures; - d3d_info->shader_color_key = fragment_caps.wined3d_caps & WINED3D_FRAGMENT_CAP_COLOR_KEY; + d3d_info->shader_color_key = !!(fragment_caps.wined3d_caps & WINED3D_FRAGMENT_CAP_COLOR_KEY); d3d_info->wined3d_creation_flags = wined3d_creation_flags; d3d_info->feature_level = feature_level_from_caps(gl_info, &shader_caps, &fragment_caps); + d3d_info->texture_npot = !!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO]; + d3d_info->texture_npot_conditional = gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT] + || gl_info->supported[ARB_TEXTURE_RECTANGLE]; + TRACE("Max texture stages: %u.\n", d3d_info->limits.ffp_blend_stages); d3d_info->valid_rt_mask = 0; diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 919c3e76084..81c3b5d492d 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2018,31 +2018,27 @@ HRESULT CDECL wined3d_get_device_caps(const struct wined3d *wined3d, UINT adapte WINED3DPTEXTURECAPS_PROJECTED | WINED3DPTEXTURECAPS_PERSPECTIVE; - if (!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO]) + if (!d3d_info->texture_npot) { caps->TextureCaps |= WINED3DPTEXTURECAPS_POW2; - if (gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT] || gl_info->supported[ARB_TEXTURE_RECTANGLE]) + if (d3d_info->texture_npot_conditional) caps->TextureCaps |= WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL; } if (gl_info->supported[EXT_TEXTURE3D]) { - caps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP | - WINED3DPTEXTURECAPS_MIPVOLUMEMAP; - if (!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO]) - { + caps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP + | WINED3DPTEXTURECAPS_MIPVOLUMEMAP; + if (!d3d_info->texture_npot) caps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP_POW2; - } } if (gl_info->supported[ARB_TEXTURE_CUBE_MAP]) { - caps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP | - WINED3DPTEXTURECAPS_MIPCUBEMAP; - if (!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO]) - { + caps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP + | WINED3DPTEXTURECAPS_MIPCUBEMAP; + if (!d3d_info->texture_npot) caps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP_POW2; - } } caps->TextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR | diff --git a/dlls/wined3d/resource.c b/dlls/wined3d/resource.c index a3dadec3ab1..6cb1ac47b4e 100644 --- a/dlls/wined3d/resource.c +++ b/dlls/wined3d/resource.c @@ -60,6 +60,7 @@ HRESULT resource_init(struct wined3d_resource *resource, struct wined3d_device * unsigned int size, void *parent, const struct wined3d_parent_ops *parent_ops, const struct wined3d_resource_ops *resource_ops) { + const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info; enum wined3d_gl_resource_type base_type = WINED3D_GL_RES_TYPE_COUNT; enum wined3d_gl_resource_type gl_type = WINED3D_GL_RES_TYPE_COUNT; const struct wined3d_gl_info *gl_info = &device->adapter->gl_info; @@ -129,7 +130,7 @@ HRESULT resource_init(struct wined3d_resource *resource, struct wined3d_device * continue; } if (((width & (width - 1)) || (height & (height - 1))) - && !gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] + && !d3d_info->texture_npot && !gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT] && gl_type == WINED3D_GL_RES_TYPE_TEX_2D) { diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c index 8f499d4ada6..b878e38961e 100644 --- a/dlls/wined3d/texture.c +++ b/dlls/wined3d/texture.c @@ -1535,6 +1535,7 @@ HRESULT CDECL wined3d_texture_update_desc(struct wined3d_texture *texture, UINT UINT multisample_quality, void *mem, UINT pitch) { struct wined3d_texture_sub_resource *sub_resource; + const struct wined3d_d3d_info *d3d_info; const struct wined3d_gl_info *gl_info; const struct wined3d_format *format; struct wined3d_device *device; @@ -1548,6 +1549,7 @@ HRESULT CDECL wined3d_texture_update_desc(struct wined3d_texture *texture, UINT device = texture->resource.device; gl_info = &device->adapter->gl_info; + d3d_info = &device->adapter->d3d_info; format = wined3d_get_format(device->adapter, format_id, texture->resource.usage); resource_size = wined3d_format_calculate_size(format, device->surface_alignment, width, height, 1); @@ -1622,8 +1624,8 @@ HRESULT CDECL wined3d_texture_update_desc(struct wined3d_texture *texture, UINT else texture->target = GL_TEXTURE_2D; - if (((width & (width - 1)) || (height & (height - 1))) && !gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] - && !gl_info->supported[ARB_TEXTURE_RECTANGLE] && !gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT]) + if (((width & (width - 1)) || (height & (height - 1))) && !d3d_info->texture_npot + && !d3d_info->texture_npot_conditional) { texture->flags |= WINED3D_TEXTURE_COND_NP2_EMULATED; texture->pow2_width = texture->pow2_height = 1; @@ -2571,6 +2573,7 @@ static HRESULT wined3d_texture_init(struct wined3d_texture *texture, const struc unsigned int layer_count, unsigned int level_count, DWORD flags, struct wined3d_device *device, void *parent, const struct wined3d_parent_ops *parent_ops, const struct wined3d_texture_ops *texture_ops) { + const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info; struct wined3d_device_parent *device_parent = device->device_parent; const struct wined3d_gl_info *gl_info = &device->adapter->gl_info; unsigned int sub_count, i, j, size, offset = 0; @@ -2637,7 +2640,7 @@ static HRESULT wined3d_texture_init(struct wined3d_texture *texture, const struc pow2_width = desc->width; pow2_height = desc->height; if (((desc->width & (desc->width - 1)) || (desc->height & (desc->height - 1)) || (desc->depth & (desc->depth - 1))) - && !gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO]) + && !d3d_info->texture_npot) { /* level_count == 0 returns an error as well. */ if (level_count != 1 || layer_count != 1 || desc->resource_type == WINED3D_RTYPE_TEXTURE_3D) @@ -2653,8 +2656,7 @@ static HRESULT wined3d_texture_init(struct wined3d_texture *texture, const struc } texture->flags |= WINED3D_TEXTURE_COND_NP2; - if (desc->resource_type != WINED3D_RTYPE_TEXTURE_3D && !gl_info->supported[ARB_TEXTURE_RECTANGLE] - && !gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT]) + if (desc->resource_type != WINED3D_RTYPE_TEXTURE_3D && !d3d_info->texture_npot_conditional) { /* TODO: Add support for non-power-of-two compressed textures. */ if (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 850d66e1282..239873bdb1a 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -187,14 +187,16 @@ struct wined3d_d3d_info { struct wined3d_d3d_limits limits; struct wined3d_ffp_attrib_ops ffp_attrib_ops; - BOOL xyzrhw; - BOOL emulated_flatshading; - BOOL ffp_generic_attributes; - BOOL vs_clipping; - BOOL shader_color_key; DWORD valid_rt_mask; DWORD wined3d_creation_flags; - BOOL shader_double_precision; + unsigned int xyzrhw : 1; + unsigned int emulated_flatshading : 1; + unsigned int ffp_generic_attributes : 1; + unsigned int vs_clipping : 1; + unsigned int shader_color_key : 1; + unsigned int shader_double_precision : 1; + unsigned int texture_npot : 1; + unsigned int texture_npot_conditional : 1; enum wined3d_feature_level feature_level; }; -- 2.11.0

1 0

[PATCH 3/4] wined3d: Reorder the formats in debug_d3dformat() to match the enum order.
by Henri Verbeet 17 Sep '18

17 Sep '18

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/utils.c | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 9ffce6cc602..9d0a64b753d 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -4141,18 +4141,6 @@ const char *debug_d3dformat(enum wined3d_format_id format_id) FMT_TO_STR(WINED3DFMT_R10G10B10X2_UINT); FMT_TO_STR(WINED3DFMT_R10G10B10X2_SNORM); FMT_TO_STR(WINED3DFMT_R10G10B10_SNORM_A2_UNORM); - FMT_TO_STR(WINED3DFMT_UYVY); - FMT_TO_STR(WINED3DFMT_YUY2); - FMT_TO_STR(WINED3DFMT_YV12); - FMT_TO_STR(WINED3DFMT_NV12); - FMT_TO_STR(WINED3DFMT_DXT1); - FMT_TO_STR(WINED3DFMT_DXT2); - FMT_TO_STR(WINED3DFMT_DXT3); - FMT_TO_STR(WINED3DFMT_DXT4); - FMT_TO_STR(WINED3DFMT_DXT5); - FMT_TO_STR(WINED3DFMT_MULTI2_ARGB8); - FMT_TO_STR(WINED3DFMT_G8R8_G8B8); - FMT_TO_STR(WINED3DFMT_R8G8_B8G8); FMT_TO_STR(WINED3DFMT_D16_LOCKABLE); FMT_TO_STR(WINED3DFMT_D32_UNORM); FMT_TO_STR(WINED3DFMT_S1_UINT_D15_UNORM); @@ -4161,12 +4149,6 @@ const char *debug_d3dformat(enum wined3d_format_id format_id) FMT_TO_STR(WINED3DFMT_L16_UNORM); FMT_TO_STR(WINED3DFMT_S8_UINT_D24_FLOAT); FMT_TO_STR(WINED3DFMT_R8G8_SNORM_Cx); - FMT_TO_STR(WINED3DFMT_ATI1N); - FMT_TO_STR(WINED3DFMT_ATI2N); - FMT_TO_STR(WINED3DFMT_INST); - FMT_TO_STR(WINED3DFMT_NVDB); - FMT_TO_STR(WINED3DFMT_NVHU); - FMT_TO_STR(WINED3DFMT_NVHS); FMT_TO_STR(WINED3DFMT_R32G32B32A32_TYPELESS); FMT_TO_STR(WINED3DFMT_R32G32B32A32_FLOAT); FMT_TO_STR(WINED3DFMT_R32G32B32A32_UINT); @@ -4267,11 +4249,29 @@ const char *debug_d3dformat(enum wined3d_format_id format_id) FMT_TO_STR(WINED3DFMT_BC7_TYPELESS); FMT_TO_STR(WINED3DFMT_BC7_UNORM); FMT_TO_STR(WINED3DFMT_BC7_UNORM_SRGB); + FMT_TO_STR(WINED3DFMT_UYVY); + FMT_TO_STR(WINED3DFMT_YUY2); + FMT_TO_STR(WINED3DFMT_YV12); + FMT_TO_STR(WINED3DFMT_DXT1); + FMT_TO_STR(WINED3DFMT_DXT2); + FMT_TO_STR(WINED3DFMT_DXT3); + FMT_TO_STR(WINED3DFMT_DXT4); + FMT_TO_STR(WINED3DFMT_DXT5); + FMT_TO_STR(WINED3DFMT_MULTI2_ARGB8); + FMT_TO_STR(WINED3DFMT_G8R8_G8B8); + FMT_TO_STR(WINED3DFMT_R8G8_B8G8); + FMT_TO_STR(WINED3DFMT_ATI1N); + FMT_TO_STR(WINED3DFMT_ATI2N); + FMT_TO_STR(WINED3DFMT_INST); + FMT_TO_STR(WINED3DFMT_NVDB); + FMT_TO_STR(WINED3DFMT_NVHU); + FMT_TO_STR(WINED3DFMT_NVHS); FMT_TO_STR(WINED3DFMT_INTZ); FMT_TO_STR(WINED3DFMT_RESZ); FMT_TO_STR(WINED3DFMT_NULL); FMT_TO_STR(WINED3DFMT_R16); FMT_TO_STR(WINED3DFMT_AL16); + FMT_TO_STR(WINED3DFMT_NV12); #undef FMT_TO_STR default: { -- 2.11.0

1 0

[PATCH 2/4] wined3d: Properly initialise the driver info in wined3d_adapter_no3d_init().
by Henri Verbeet 17 Sep '18

17 Sep '18

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/adapter_gl.c | 15 ++++----------- dlls/wined3d/directx.c | 25 +++++++++++++++++++------ dlls/wined3d/wined3d_private.h | 1 + 3 files changed, 24 insertions(+), 17 deletions(-) diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index 6f39a3e0c66..f3862cd32c3 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -1015,13 +1015,6 @@ static const struct wined3d_gpu_description *query_gpu_description(const struct TRACE("Overriding device PCI ID with 0x%04x.\n", device); } - if (wined3d_settings.emulated_textureram) - { - *vram_bytes = wined3d_settings.emulated_textureram; - TRACE("Overriding amount of video memory with 0x%s bytes.\n", - wine_dbgstr_longlong(*vram_bytes)); - } - if (!(gpu_description = wined3d_get_gpu_description(vendor, device)) && (wined3d_settings.pci_vendor_id != PCI_VENDOR_NONE || wined3d_settings.pci_device_id != PCI_DEVICE_NONE) && !once++) @@ -3816,6 +3809,10 @@ static BOOL wined3d_adapter_init_gl_caps(struct wined3d_adapter *adapter, TRACE("Reporting (fake) driver version 0x%08x-0x%08x.\n", driver_info->version_high, driver_info->version_low); + adapter->vram_bytes = driver_info->vram_bytes; + adapter->vram_bytes_used = 0; + TRACE("Emulating 0x%s bytes of video ram.\n", wine_dbgstr_longlong(adapter->vram_bytes)); + gl_ext_emul_mask = adapter->vertex_pipe->vp_get_emul_mask(gl_info) | adapter->fragment_pipe->get_emul_mask(gl_info); if (gl_ext_emul_mask & GL_EXT_EMUL_ARB_MULTITEXTURE) @@ -4286,10 +4283,6 @@ BOOL wined3d_adapter_opengl_init(struct wined3d_adapter *adapter, DWORD wined3d_ return FALSE; } - adapter->vram_bytes = adapter->driver_info.vram_bytes; - adapter->vram_bytes_used = 0; - TRACE("Emulating 0x%s bytes of video ram.\n", wine_dbgstr_longlong(adapter->vram_bytes)); - wined3d_caps_gl_ctx_destroy(&caps_gl_ctx); wined3d_adapter_init_ffp_attrib_ops(adapter); diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 36005064284..919c3e76084 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -189,6 +189,9 @@ static const struct driver_version_information driver_version_table[] = /* VMware */ {DRIVER_VMWARE, DRIVER_MODEL_NT5X, "vm3dum.dll", 14, 1, 1134}, + + /* Wine */ + {DRIVER_WINE, DRIVER_MODEL_GENERIC, "wined3d.dll", 0, 0, 0}, }; /* The amount of video memory stored in the gpu description table is the minimum amount of video memory @@ -563,6 +566,13 @@ void wined3d_driver_info_init(struct wined3d_driver_info *driver_info, driver_info->vram_bytes = vram_bytes ? vram_bytes : (UINT64)gpu_desc->vidmem * 1024 * 1024; driver = gpu_desc->driver; + if (wined3d_settings.emulated_textureram) + { + driver_info->vram_bytes = wined3d_settings.emulated_textureram; + TRACE("Overriding amount of video memory with 0x%s bytes.\n", + wine_dbgstr_longlong(driver_info->vram_bytes)); + } + /** * Diablo 2 crashes when the amount of video memory is greater than 0x7fffffff. * In order to avoid this application bug we limit the amount of video memory @@ -2473,14 +2483,17 @@ static const struct wined3d_adapter_ops wined3d_adapter_no3d_ops = static BOOL wined3d_adapter_no3d_init(struct wined3d_adapter *adapter) { + static const struct wined3d_gpu_description gpu_description = + { + HW_VENDOR_SOFTWARE, CARD_WINE, "WineD3D DirectDraw Emulation", DRIVER_WINE, 128, + }; + TRACE("adapter %p.\n", adapter); - adapter->driver_info.name = "Display"; - adapter->driver_info.description = "WineD3D DirectDraw Emulation"; - if (wined3d_settings.emulated_textureram) - adapter->vram_bytes = wined3d_settings.emulated_textureram; - else - adapter->vram_bytes = 128 * 1024 * 1024; + wined3d_driver_info_init(&adapter->driver_info, &gpu_description, 0); + adapter->vram_bytes = adapter->driver_info.vram_bytes; + adapter->vram_bytes_used = 0; + TRACE("Emulating 0x%s bytes of video ram.\n", wine_dbgstr_longlong(adapter->vram_bytes)); if (!wined3d_adapter_init_format_info(adapter, NULL)) return FALSE; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 69eda3ebb64..850d66e1282 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2607,6 +2607,7 @@ enum wined3d_display_driver DRIVER_NVIDIA_GEFORCE6, DRIVER_NVIDIA_GEFORCE8, DRIVER_VMWARE, + DRIVER_WINE, DRIVER_UNKNOWN, }; -- 2.11.0

1 0

[PATCH 1/4] wined3d: Get rid of the "format_count" field from struct wined3d_adapter.
by Henri Verbeet 17 Sep '18

17 Sep '18

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/directx.c | 1 - dlls/wined3d/utils.c | 13 ++++++------- dlls/wined3d/wined3d_private.h | 1 - 3 files changed, 6 insertions(+), 9 deletions(-) diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index ab6a452a2e8..36005064284 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2513,7 +2513,6 @@ static BOOL wined3d_adapter_init(struct wined3d_adapter *adapter, unsigned int o adapter->luid.HighPart, adapter->luid.LowPart, adapter); adapter->formats = NULL; - adapter->format_count = 0; if (wined3d_creation_flags & WINED3D_NO3D) return wined3d_adapter_no3d_init(adapter); diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index db27270ba8a..9ffce6cc602 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -1993,8 +1993,7 @@ static BOOL init_format_base_info(struct wined3d_adapter *adapter) struct wined3d_format *format; unsigned int i, j; - adapter->format_count = WINED3D_FORMAT_COUNT; - if (!(adapter->formats = heap_calloc(adapter->format_count + if (!(adapter->formats = heap_calloc(WINED3D_FORMAT_COUNT + ARRAY_SIZE(typeless_depth_stencil_formats), sizeof(*adapter->formats)))) { ERR("Failed to allocate memory.\n"); @@ -2728,7 +2727,7 @@ static void init_format_fbo_compat_info(const struct wined3d_adapter *adapter, if (gl_info->supported[ARB_INTERNALFORMAT_QUERY2]) { - for (i = 0; i < adapter->format_count; ++i) + for (i = 0; i < WINED3D_FORMAT_COUNT; ++i) { BOOL fallback_fmt_used = FALSE, regular_fmt_used = FALSE; struct wined3d_format *format = &adapter->formats[i]; @@ -2842,7 +2841,7 @@ static void init_format_fbo_compat_info(const struct wined3d_adapter *adapter, gl_info->gl_ops.gl.p_glReadBuffer(GL_COLOR_ATTACHMENT0); } - for (i = 0; i < adapter->format_count; ++i) + for (i = 0; i < WINED3D_FORMAT_COUNT; ++i) { struct wined3d_format *format = &adapter->formats[i]; @@ -3621,7 +3620,7 @@ static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_ format_set_flag(format, WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET); } - for (i = 0; i < adapter->format_count; ++i) + for (i = 0; i < WINED3D_FORMAT_COUNT; ++i) { struct wined3d_format *format = &adapter->formats[i]; @@ -3756,7 +3755,7 @@ static void init_format_gen_mipmap_info(const struct wined3d_adapter *adapter, if (!gl_info->fbo_ops.glGenerateMipmap) return; - for (i = 0; i < adapter->format_count; ++i) + for (i = 0; i < WINED3D_FORMAT_COUNT; ++i) { struct wined3d_format *format = &adapter->formats[i]; @@ -3913,7 +3912,7 @@ static void init_format_depth_bias_scale(struct wined3d_adapter *adapter, const struct wined3d_d3d_info *d3d_info = &adapter->d3d_info; unsigned int i; - for (i = 0; i < adapter->format_count; ++i) + for (i = 0; i < WINED3D_FORMAT_COUNT; ++i) { struct wined3d_format *format = &adapter->formats[i]; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index b96d3a53c09..69eda3ebb64 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2665,7 +2665,6 @@ struct wined3d_adapter LUID luid; struct wined3d_format *formats; - unsigned int format_count; const struct wined3d_vertex_pipe_ops *vertex_pipe; const struct fragment_pipeline *fragment_pipe; -- 2.11.0

1 0

[PATCH] wineboot: Create user folders if they don't exist.
by Zhiyi Zhang 17 Sep '18

17 Sep '18

When creating volatile environment registry keys during first wineprefix creation, none of the user folders are existent. Create them before setting registry keys so that volatile environment gets initialized and corresponding environment variables such as %USERPROFILE% can be set. Otherwise, such environment variables are set only after another wineboot, causing applications to fail if they need them after first boot. Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- programs/wineboot/wineboot.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/programs/wineboot/wineboot.c b/programs/wineboot/wineboot.c index 17ef9cbcca..075b4c8b08 100644 --- a/programs/wineboot/wineboot.c +++ b/programs/wineboot/wineboot.c @@ -385,14 +385,14 @@ static void create_volatile_environment_registry_key(void) KEY_ALL_ACCESS, NULL, &hkey, NULL )) return; - hr = SHGetFolderPathW( NULL, CSIDL_APPDATA, NULL, SHGFP_TYPE_CURRENT, path ); + hr = SHGetFolderPathW( NULL, CSIDL_APPDATA | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, path ); if (SUCCEEDED(hr)) set_reg_value( hkey, AppDataW, path ); set_reg_value( hkey, ClientNameW, ConsoleW ); /* Write the profile path's drive letter and directory components into * HOMEDRIVE and HOMEPATH respectively. */ - hr = SHGetFolderPathW( NULL, CSIDL_PROFILE, NULL, SHGFP_TYPE_CURRENT, path ); + hr = SHGetFolderPathW( NULL, CSIDL_PROFILE | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, path ); if (SUCCEEDED(hr)) { set_reg_value( hkey, UserProfileW, path ); @@ -406,7 +406,7 @@ static void create_volatile_environment_registry_key(void) set_reg_value( hkey, HomeShareW, EmptyW ); - hr = SHGetFolderPathW( NULL, CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, path ); + hr = SHGetFolderPathW( NULL, CSIDL_LOCAL_APPDATA | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, path ); if (SUCCEEDED(hr)) set_reg_value( hkey, LocalAppDataW, path ); -- 2.18.0

1 0

[PATCH] windowscodecs: IWICMetadataQueryReader::GetMetadataByName() should accept NULL for returned value.
by Dmitry Timoshkov 17 Sep '18

17 Sep '18

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/windowscodecs/metadataquery.c | 2 +- dlls/windowscodecs/tests/metadata.c | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/dlls/windowscodecs/metadataquery.c b/dlls/windowscodecs/metadataquery.c index 2d7c918921..c4c188d8c9 100644 --- a/dlls/windowscodecs/metadataquery.c +++ b/dlls/windowscodecs/metadataquery.c @@ -589,7 +589,7 @@ static HRESULT WINAPI mqr_GetMetadataByName(IWICMetadataQueryReader *iface, LPCW PropVariantClear(&tk_id); PropVariantClear(&tk_schema); - if (hr == S_OK) + if (hr == S_OK && value) *value = new_value; else PropVariantClear(&new_value); diff --git a/dlls/windowscodecs/tests/metadata.c b/dlls/windowscodecs/tests/metadata.c index eb846db0b8..b434648fe5 100644 --- a/dlls/windowscodecs/tests/metadata.c +++ b/dlls/windowscodecs/tests/metadata.c @@ -1606,6 +1606,10 @@ static void test_metadata_gif(void) if (winetest_debug > 1) trace("query: %s\n", decoder_data[i].query); MultiByteToWideChar(CP_ACP, 0, decoder_data[i].query, -1, queryW, 256); + + hr = IWICMetadataQueryReader_GetMetadataByName(queryreader, queryW, NULL); + ok(hr == decoder_data[i].hr, "GetMetadataByName(%s) returned %#x, expected %#x\n", wine_dbgstr_w(queryW), hr, decoder_data[i].hr); + PropVariantInit(&value); hr = IWICMetadataQueryReader_GetMetadataByName(queryreader, queryW, &value); ok(hr == decoder_data[i].hr, "GetMetadataByName(%s) returned %#x, expected %#x\n", wine_dbgstr_w(queryW), hr, decoder_data[i].hr); -- 2.17.1

2 1

[PATCH] mshtml: Make HTMLStyle_init_dispex_info() static.
by Francois Gouget 17 Sep '18

17 Sep '18

Signed-off-by: Francois Gouget <fgouget(a)free.fr> --- dlls/mshtml/htmlstyle.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/mshtml/htmlstyle.c b/dlls/mshtml/htmlstyle.c index b61641d22bc..20930aa9ed5 100644 --- a/dlls/mshtml/htmlstyle.c +++ b/dlls/mshtml/htmlstyle.c @@ -10070,7 +10070,7 @@ static HRESULT HTMLStyle_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, return DISP_E_UNKNOWNNAME; } -void HTMLStyle_init_dispex_info(dispex_data_t *info, compat_mode_t mode) +static void HTMLStyle_init_dispex_info(dispex_data_t *info, compat_mode_t mode) { if(mode >= COMPAT_MODE_IE9) dispex_info_add_interface(info, IHTMLCSSStyleDeclaration_tid, NULL); -- 2.18.0

2 1

[PATCH 2/2] d3d11: Add D3D11On12CreateDevice() stub.
by Józef Kucia 17 Sep '18

17 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/d3d11/d3d11.spec | 1 + dlls/d3d11/d3d11_main.c | 15 +++++++++++++++ 2 files changed, 16 insertions(+) diff --git a/dlls/d3d11/d3d11.spec b/dlls/d3d11/d3d11.spec index 60c77f9d3097..267778ab1439 100644 --- a/dlls/d3d11/d3d11.spec +++ b/dlls/d3d11/d3d11.spec @@ -4,6 +4,7 @@ @ stdcall D3D11CoreRegisterLayers() @ stdcall D3D11CreateDevice(ptr long ptr long ptr long long ptr ptr ptr) @ stdcall D3D11CreateDeviceAndSwapChain(ptr long ptr long ptr long long ptr ptr ptr ptr ptr) +@ stdcall D3D11On12CreateDevice(ptr long ptr long ptr long long ptr ptr ptr) @ stub D3DKMTCloseAdapter @ stub D3DKMTCreateAllocation @ stub D3DKMTCreateContext diff --git a/dlls/d3d11/d3d11_main.c b/dlls/d3d11/d3d11_main.c index 5d085edf2fee..6d981160f245 100644 --- a/dlls/d3d11/d3d11_main.c +++ b/dlls/d3d11/d3d11_main.c @@ -377,3 +377,18 @@ cleanup: return hr; } + +HRESULT WINAPI D3D11On12CreateDevice(IUnknown *device, UINT flags, + const D3D_FEATURE_LEVEL *feature_levels, UINT feature_level_count, + IUnknown * const *queues, UINT queue_count, UINT node_mask, + ID3D11Device **d3d11_device, ID3D11DeviceContext **d3d11_immediate_context, + D3D_FEATURE_LEVEL *obtained_feature_level) +{ + FIXME("device %p, flags %#x, feature_levels %p, feature_level_count %u, " + "queues %p, queue_count %u, node_mask 0x%08x, " + "d3d11_device %p, d3d11_immediate_context %p, obtained_feature_level %p stub!\n", + device, flags, feature_levels, feature_level_count, queues, queue_count, + node_mask, d3d11_device, d3d11_immediate_context, obtained_feature_level); + + return E_NOTIMPL; +} -- 2.16.4

2 1

[v2 PATCH 1/4] d2d1: Implement GetSurface() for bitmaps.
by Nikolay Sivov 17 Sep '18

17 Sep '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/d2d1/bitmap.c | 64 +++++++++++++++++++++----------------- dlls/d2d1/d2d1_private.h | 12 +++++-- dlls/d2d1/device.c | 9 ++---- dlls/d2d1/tests/d2d1.c | 67 ++++++++++++++++++++++++---------------- 4 files changed, 88 insertions(+), 64 deletions(-) diff --git a/dlls/d2d1/bitmap.c b/dlls/d2d1/bitmap.c index 8b5b6aa0a9..01dc829a1c 100644 --- a/dlls/d2d1/bitmap.c +++ b/dlls/d2d1/bitmap.c @@ -70,6 +70,8 @@ static ULONG STDMETHODCALLTYPE d2d_bitmap_Release(ID2D1Bitmap1 *iface) if (!refcount) { ID3D10ShaderResourceView_Release(bitmap->view); + if (bitmap->surface) + IDXGISurface_Release(bitmap->surface); ID2D1Factory_Release(bitmap->factory); heap_free(bitmap); } @@ -188,9 +190,15 @@ static D2D1_BITMAP_OPTIONS STDMETHODCALLTYPE d2d_bitmap_GetOptions(ID2D1Bitmap1 static HRESULT STDMETHODCALLTYPE d2d_bitmap_GetSurface(ID2D1Bitmap1 *iface, IDXGISurface **surface) { - FIXME("iface %p, surface %p stub!\n", iface, surface); + struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface); - return E_NOTIMPL; + TRACE("iface %p, surface %p.\n", iface, surface); + + *surface = bitmap->surface; + if (*surface) + IDXGISurface_AddRef(*surface); + + return *surface ? S_OK : D2DERR_INVALID_CALL; } static HRESULT STDMETHODCALLTYPE d2d_bitmap_Map(ID2D1Bitmap1 *iface, D2D1_MAP_OPTIONS options, @@ -263,18 +271,26 @@ static BOOL format_supported(const D2D1_PIXEL_FORMAT *format) return FALSE; } -static void d2d_bitmap_init(struct d2d_bitmap *bitmap, ID2D1Factory *factory, +static void d2d_bitmap_init(struct d2d_bitmap *bitmap, struct d2d_device_context *context, ID3D10ShaderResourceView *view, D2D1_SIZE_U size, const D2D1_BITMAP_PROPERTIES1 *desc) { bitmap->ID2D1Bitmap1_iface.lpVtbl = &d2d_bitmap_vtbl; bitmap->refcount = 1; - ID2D1Factory_AddRef(bitmap->factory = factory); + ID2D1Factory_AddRef(bitmap->factory = context->factory); ID3D10ShaderResourceView_AddRef(bitmap->view = view); bitmap->pixel_size = size; bitmap->format = desc->pixelFormat; bitmap->dpi_x = desc->dpiX; bitmap->dpi_y = desc->dpiY; bitmap->options = desc->bitmapOptions; + if (d2d_device_context_is_dxgi_target(context)) + { + ID3D10Resource *resource; + + ID3D10ShaderResourceView_GetResource(bitmap->view, &resource); + ID3D10Resource_QueryInterface(resource, &IID_IDXGISurface, (void **)&bitmap->surface); + ID3D10Resource_Release(resource); + } if (bitmap->dpi_x == 0.0f && bitmap->dpi_y == 0.0f) { @@ -283,7 +299,7 @@ static void d2d_bitmap_init(struct d2d_bitmap *bitmap, ID2D1Factory *factory, } } -HRESULT d2d_bitmap_create(ID2D1Factory *factory, ID3D10Device *device, D2D1_SIZE_U size, const void *src_data, +HRESULT d2d_bitmap_create(struct d2d_device_context *context, D2D1_SIZE_U size, const void *src_data, UINT32 pitch, const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap) { D3D10_SUBRESOURCE_DATA resource_data; @@ -314,14 +330,14 @@ HRESULT d2d_bitmap_create(ID2D1Factory *factory, ID3D10Device *device, D2D1_SIZE resource_data.pSysMem = src_data; resource_data.SysMemPitch = pitch; - if (FAILED(hr = ID3D10Device_CreateTexture2D(device, &texture_desc, + if (FAILED(hr = ID3D10Device_CreateTexture2D(context->device, &texture_desc, src_data ? &resource_data : NULL, &texture))) { ERR("Failed to create texture, hr %#x.\n", hr); return hr; } - hr = ID3D10Device_CreateShaderResourceView(device, (ID3D10Resource *)texture, NULL, &view); + hr = ID3D10Device_CreateShaderResourceView(context->device, (ID3D10Resource *)texture, NULL, &view); ID3D10Texture2D_Release(texture); if (FAILED(hr)) { @@ -331,7 +347,7 @@ HRESULT d2d_bitmap_create(ID2D1Factory *factory, ID3D10Device *device, D2D1_SIZE if ((*bitmap = heap_alloc_zero(sizeof(**bitmap)))) { - d2d_bitmap_init(*bitmap, factory, view, size, desc); + d2d_bitmap_init(*bitmap, context, view, size, desc); TRACE("Created bitmap %p.\n", *bitmap); } @@ -340,11 +356,10 @@ HRESULT d2d_bitmap_create(ID2D1Factory *factory, ID3D10Device *device, D2D1_SIZE return *bitmap ? S_OK : E_OUTOFMEMORY; } -HRESULT d2d_bitmap_create_shared(ID2D1DeviceContext *context, ID3D10Device *target_device, - REFIID iid, void *data, const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap) +HRESULT d2d_bitmap_create_shared(struct d2d_device_context *context, REFIID iid, void *data, + const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap) { D2D1_BITMAP_PROPERTIES1 d; - ID2D1Factory *factory; if (IsEqualGUID(iid, &IID_ID2D1Bitmap)) { @@ -352,8 +367,7 @@ HRESULT d2d_bitmap_create_shared(ID2D1DeviceContext *context, ID3D10Device *targ ID3D10Device *device; HRESULT hr = S_OK; - ID2D1DeviceContext_GetFactory(context, &factory); - if (src_impl->factory != factory) + if (src_impl->factory != context->factory) { hr = D2DERR_WRONG_FACTORY; goto failed; @@ -361,7 +375,7 @@ HRESULT d2d_bitmap_create_shared(ID2D1DeviceContext *context, ID3D10Device *targ ID3D10ShaderResourceView_GetDevice(src_impl->view, &device); ID3D10Device_Release(device); - if (device != target_device) + if (device != context->device) { hr = D2DERR_UNSUPPORTED_OPERATION; goto failed; @@ -391,11 +405,10 @@ HRESULT d2d_bitmap_create_shared(ID2D1DeviceContext *context, ID3D10Device *targ goto failed; } - d2d_bitmap_init(*bitmap, factory, src_impl->view, src_impl->pixel_size, desc); + d2d_bitmap_init(*bitmap, context, src_impl->view, src_impl->pixel_size, desc); TRACE("Created bitmap %p.\n", *bitmap); failed: - ID2D1Factory_Release(factory); return hr; } @@ -417,13 +430,13 @@ HRESULT d2d_bitmap_create_shared(ID2D1DeviceContext *context, ID3D10Device *targ ID3D10Resource_GetDevice(resource, &device); ID3D10Device_Release(device); - if (device != target_device) + if (device != context->device) { ID3D10Resource_Release(resource); return D2DERR_UNSUPPORTED_OPERATION; } - hr = ID3D10Device_CreateShaderResourceView(target_device, resource, NULL, &view); + hr = ID3D10Device_CreateShaderResourceView(context->device, resource, NULL, &view); ID3D10Resource_Release(resource); if (FAILED(hr)) { @@ -455,22 +468,17 @@ HRESULT d2d_bitmap_create_shared(ID2D1DeviceContext *context, ID3D10Device *targ if (d.dpiX == 0.0f || d.dpiY == 0.0f) { - float dpi_x, dpi_y; - - ID2D1DeviceContext_GetDpi(context, &dpi_x, &dpi_y); if (d.dpiX == 0.0f) - d.dpiX = dpi_x; + d.dpiX = context->desc.dpiX; if (d.dpiY == 0.0f) - d.dpiY = dpi_y; + d.dpiY = context->desc.dpiY; } pixel_size.width = surface_desc.Width; pixel_size.height = surface_desc.Height; - ID2D1DeviceContext_GetFactory(context, &factory); - d2d_bitmap_init(*bitmap, factory, view, pixel_size, &d); + d2d_bitmap_init(*bitmap, context, view, pixel_size, &d); ID3D10ShaderResourceView_Release(view); - ID2D1Factory_Release(factory); TRACE("Created bitmap %p.\n", *bitmap); return S_OK; @@ -481,7 +489,7 @@ HRESULT d2d_bitmap_create_shared(ID2D1DeviceContext *context, ID3D10Device *targ return E_INVALIDARG; } -HRESULT d2d_bitmap_create_from_wic_bitmap(ID2D1Factory *factory, ID3D10Device *device, IWICBitmapSource *bitmap_source, +HRESULT d2d_bitmap_create_from_wic_bitmap(struct d2d_device_context *context, IWICBitmapSource *bitmap_source, const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap) { const D2D1_PIXEL_FORMAT *d2d_format; @@ -581,7 +589,7 @@ HRESULT d2d_bitmap_create_from_wic_bitmap(ID2D1Factory *factory, ID3D10Device *d return hr; } - hr = d2d_bitmap_create(factory, device, size, data, pitch, &bitmap_desc, bitmap); + hr = d2d_bitmap_create(context, size, data, pitch, &bitmap_desc, bitmap); heap_free(data); diff --git a/dlls/d2d1/d2d1_private.h b/dlls/d2d1/d2d1_private.h index 5b96a6050d..3fed59fa72 100644 --- a/dlls/d2d1/d2d1_private.h +++ b/dlls/d2d1/d2d1_private.h @@ -160,6 +160,11 @@ HRESULT d2d_d3d_create_render_target(ID2D1Factory *factory, IDXGISurface *surfac void **render_target) DECLSPEC_HIDDEN; HRESULT d2d_d3d_render_target_create_rtv(ID2D1RenderTarget *render_target, IDXGISurface1 *surface) DECLSPEC_HIDDEN; +static inline BOOL d2d_device_context_is_dxgi_target(const struct d2d_device_context *context) +{ + return !context->ops; +} + struct d2d_wic_render_target { IUnknown IUnknown_iface; @@ -339,6 +344,7 @@ struct d2d_bitmap ID2D1Factory *factory; ID3D10ShaderResourceView *view; + IDXGISurface *surface; D2D1_SIZE_U pixel_size; D2D1_PIXEL_FORMAT format; float dpi_x; @@ -346,11 +352,11 @@ struct d2d_bitmap D2D1_BITMAP_OPTIONS options; }; -HRESULT d2d_bitmap_create(ID2D1Factory *factory, ID3D10Device *device, D2D1_SIZE_U size, const void *src_data, +HRESULT d2d_bitmap_create(struct d2d_device_context *context, D2D1_SIZE_U size, const void *src_data, UINT32 pitch, const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap) DECLSPEC_HIDDEN; -HRESULT d2d_bitmap_create_shared(ID2D1DeviceContext *context, ID3D10Device *device, REFIID iid, void *data, +HRESULT d2d_bitmap_create_shared(struct d2d_device_context *context, REFIID iid, void *data, const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap) DECLSPEC_HIDDEN; -HRESULT d2d_bitmap_create_from_wic_bitmap(ID2D1Factory *factory, ID3D10Device *device, IWICBitmapSource *bitmap_source, +HRESULT d2d_bitmap_create_from_wic_bitmap(struct d2d_device_context *context, IWICBitmapSource *bitmap_source, const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap) DECLSPEC_HIDDEN; struct d2d_bitmap *unsafe_impl_from_ID2D1Bitmap(ID2D1Bitmap *iface) DECLSPEC_HIDDEN; diff --git a/dlls/d2d1/device.c b/dlls/d2d1/device.c index 649fcc4311..041cb33c90 100644 --- a/dlls/d2d1/device.c +++ b/dlls/d2d1/device.c @@ -343,8 +343,7 @@ static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateBitmap(ID2D1DeviceCont bitmap_desc.colorContext = NULL; } - if (SUCCEEDED(hr = d2d_bitmap_create(context->factory, context->device, - size, src_data, pitch, desc ? &bitmap_desc : NULL, &object))) + if (SUCCEEDED(hr = d2d_bitmap_create(context, size, src_data, pitch, desc ? &bitmap_desc : NULL, &object))) *bitmap = (ID2D1Bitmap *)&object->ID2D1Bitmap1_iface; return hr; @@ -368,8 +367,7 @@ static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateBitmapFromWicBitmap(ID bitmap_desc.colorContext = NULL; } - if (SUCCEEDED(hr = d2d_bitmap_create_from_wic_bitmap(context->factory, context->device, - bitmap_source, desc ? &bitmap_desc : NULL, &object))) + if (SUCCEEDED(hr = d2d_bitmap_create_from_wic_bitmap(context, bitmap_source, desc ? &bitmap_desc : NULL, &object))) *bitmap = (ID2D1Bitmap *)&object->ID2D1Bitmap1_iface; return hr; @@ -393,8 +391,7 @@ static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateSharedBitmap(ID2D1Devi bitmap_desc.colorContext = NULL; } - if (SUCCEEDED(hr = d2d_bitmap_create_shared(iface, context->device, - iid, data, desc ? &bitmap_desc : NULL, &object))) + if (SUCCEEDED(hr = d2d_bitmap_create_shared(context, iid, data, desc ? &bitmap_desc : NULL, &object))) *bitmap = (ID2D1Bitmap *)&object->ID2D1Bitmap1_iface; return hr; diff --git a/dlls/d2d1/tests/d2d1.c b/dlls/d2d1/tests/d2d1.c index 1753d6282f..6419df23d8 100644 --- a/dlls/d2d1/tests/d2d1.c +++ b/dlls/d2d1/tests/d2d1.c @@ -774,29 +774,31 @@ static ID2D1RenderTarget *create_render_target(IDXGISurface *surface) } #define check_bitmap_surface(b, s, o) check_bitmap_surface_(__LINE__, b, s, o) -static void check_bitmap_surface_(unsigned int line, ID2D1Bitmap1 *bitmap, BOOL has_surface, DWORD expected_options) +static void check_bitmap_surface_(unsigned int line, ID2D1Bitmap *bitmap, BOOL has_surface, DWORD expected_options) { D2D1_BITMAP_OPTIONS options; IDXGISurface *surface; + ID2D1Bitmap1 *bitmap1; HRESULT hr; - options = ID2D1Bitmap1_GetOptions(bitmap); + hr = ID2D1Bitmap_QueryInterface(bitmap, &IID_ID2D1Bitmap1, (void **)&bitmap1); + if (FAILED(hr)) + return; + + options = ID2D1Bitmap1_GetOptions(bitmap1); ok_(__FILE__, line)(options == expected_options, "Unexpected bitmap options %#x, expected %#x.\n", options, expected_options); surface = (void *)0xdeadbeef; - hr = ID2D1Bitmap1_GetSurface(bitmap, &surface); + hr = ID2D1Bitmap1_GetSurface(bitmap1, &surface); if (has_surface) { D3D10_TEXTURE2D_DESC desc; ID3D10Texture2D *texture; - todo_wine ok_(__FILE__, line)(SUCCEEDED(hr), "Failed to get bitmap surface, hr %#x.\n", hr); ok_(__FILE__, line)(!!surface, "Expected surface instance.\n"); - if (SUCCEEDED(hr)) - { /* Correlate with resource configuration. */ hr = IDXGISurface_QueryInterface(surface, &IID_ID3D10Texture2D, (void **)&texture); ok_(__FILE__, line)(SUCCEEDED(hr), "Failed to get texture pointer, hr %#x.\n", hr); @@ -813,14 +815,13 @@ static void check_bitmap_surface_(unsigned int line, ID2D1Bitmap1 *bitmap, BOOL IDXGISurface_Release(surface); } - } else { - todo_wine { ok_(__FILE__, line)(hr == D2DERR_INVALID_CALL, "Unexpected hr %#x.\n", hr); ok_(__FILE__, line)(!surface, "Unexpected surface instance.\n"); } - } + + ID2D1Bitmap1_Release(bitmap1); } static inline struct geometry_sink *impl_from_ID2D1SimplifiedGeometrySink(ID2D1SimplifiedGeometrySink *iface) @@ -4132,12 +4133,14 @@ static void test_shared_bitmap(void) hr = ID2D1Factory_CreateDxgiSurfaceRenderTarget(factory1, surface1, &desc, &rt1); ok(SUCCEEDED(hr), "Failed to create render target, hr %#x.\n", hr); hr = ID2D1RenderTarget_CreateBitmap(rt1, size, NULL, 0, &bitmap_desc, &bitmap1); + check_bitmap_surface(bitmap1, TRUE, 0); ok(SUCCEEDED(hr), "Failed to create bitmap, hr %#x.\n", hr); hr = ID2D1Factory_CreateDxgiSurfaceRenderTarget(factory1, surface2, &desc, &rt2); ok(SUCCEEDED(hr), "Failed to create render target, hr %#x.\n", hr); hr = ID2D1RenderTarget_CreateSharedBitmap(rt2, &IID_ID2D1Bitmap, bitmap1, NULL, &bitmap2); ok(SUCCEEDED(hr), "Failed to create bitmap, hr %#x.\n", hr); + check_bitmap_surface(bitmap2, TRUE, 0); ID2D1Bitmap_Release(bitmap2); hr = ID2D1RenderTarget_CreateSharedBitmap(rt2, &IID_IUnknown, bitmap1, NULL, &bitmap2); ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr); @@ -4206,6 +4209,7 @@ static void test_shared_bitmap(void) ok(SUCCEEDED(hr), "Failed to create render target, hr %#x.\n", hr); hr = ID2D1RenderTarget_CreateSharedBitmap(rt2, &IID_ID2D1Bitmap, bitmap1, NULL, &bitmap2); ok(SUCCEEDED(hr), "Failed to create bitmap, hr %#x.\n", hr); + check_bitmap_surface(bitmap2, FALSE, 0); ID2D1Bitmap_Release(bitmap2); ID2D1RenderTarget_Release(rt2); @@ -4231,18 +4235,12 @@ static void test_shared_bitmap(void) if (SUCCEEDED(hr)) { - ID2D1Bitmap1 *bitmap3; - size = ID2D1Bitmap_GetPixelSize(bitmap2); hr = IDXGISurface_GetDesc(surface2, &surface_desc); ok(SUCCEEDED(hr), "Failed to get surface description, hr %#x.\n", hr); ok(size.width == surface_desc.Width && size.height == surface_desc.Height, "Got wrong bitmap size.\n"); - hr = ID2D1Bitmap_QueryInterface(bitmap2, &IID_ID2D1Bitmap1, (void **)&bitmap3); - ok(SUCCEEDED(hr), "Failed to get ID2D1Bitmap1 pointer, hr %#x.\n", hr); - - check_bitmap_surface(bitmap3, TRUE, D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW); - ID2D1Bitmap1_Release(bitmap3); + check_bitmap_surface(bitmap2, TRUE, D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW); ID2D1Bitmap_Release(bitmap2); @@ -6661,8 +6659,9 @@ static void check_rt_bitmap_surface_(unsigned int line, ID2D1RenderTarget *rt, B { D2D1_BITMAP_PROPERTIES bitmap_desc; ID2D1RenderTarget *compatible_rt; + IWICImagingFactory *wic_factory; ID2D1DeviceContext *context; - ID2D1Bitmap1 *bitmap1; + IWICBitmap *wic_bitmap; ID2D1Bitmap *bitmap; D2D1_SIZE_U size; HRESULT hr; @@ -6672,6 +6671,7 @@ static void check_rt_bitmap_surface_(unsigned int line, ID2D1RenderTarget *rt, B 0x7f7f0000, }; + /* Raw data bitmap. */ set_size_u(&size, 1, 1); bitmap_desc.pixelFormat.format = DXGI_FORMAT_B8G8R8A8_UNORM; bitmap_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_IGNORE; @@ -6680,14 +6680,31 @@ static void check_rt_bitmap_surface_(unsigned int line, ID2D1RenderTarget *rt, B hr = ID2D1RenderTarget_CreateBitmap(rt, size, bitmap_data, sizeof(*bitmap_data), &bitmap_desc, &bitmap); ok_(__FILE__, line)(SUCCEEDED(hr), "Failed to create bitmap, hr %#x.\n", hr); - hr = ID2D1Bitmap_QueryInterface(bitmap, &IID_ID2D1Bitmap1, (void **)&bitmap1); - ok_(__FILE__, line)(SUCCEEDED(hr), "Failed to get ID2D1Bitmap1 interface, hr %#x.\n", hr); + check_bitmap_surface_(line, bitmap, has_surface, options); - check_bitmap_surface_(line, bitmap1, has_surface, options); + ID2D1Bitmap_Release(bitmap); + + /* WIC bitmap. */ + CoInitializeEx(NULL, COINIT_APARTMENTTHREADED); + + hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, + &IID_IWICImagingFactory, (void **)&wic_factory); + ok_(__FILE__, line)(SUCCEEDED(hr), "Failed to create WIC imaging factory, hr %#x.\n", hr); + + hr = IWICImagingFactory_CreateBitmap(wic_factory, 16, 16, + &GUID_WICPixelFormat32bppPBGRA, WICBitmapCacheOnDemand, &wic_bitmap); + ok_(__FILE__, line)(SUCCEEDED(hr), "Failed to create WIC bitmap, hr %#x.\n", hr); + IWICImagingFactory_Release(wic_factory); + + hr = ID2D1RenderTarget_CreateBitmapFromWicBitmap(rt, (IWICBitmapSource *)wic_bitmap, NULL, &bitmap); + ok_(__FILE__, line)(SUCCEEDED(hr), "Failed to create bitmap from WIC source, hr %#x.\n", hr); + + check_bitmap_surface_(line, bitmap, has_surface, options); - ID2D1Bitmap1_Release(bitmap1); ID2D1Bitmap_Release(bitmap); + CoUninitialize(); + if (FAILED(ID2D1RenderTarget_QueryInterface(rt, &IID_ID2D1DeviceContext, (void **)&context))) { /* Compatible target follows its parent. */ @@ -6698,13 +6715,9 @@ static void check_rt_bitmap_surface_(unsigned int line, ID2D1RenderTarget *rt, B hr = ID2D1RenderTarget_CreateBitmap(compatible_rt, size, bitmap_data, sizeof(*bitmap_data), &bitmap_desc, &bitmap); ok_(__FILE__, line)(SUCCEEDED(hr), "Failed to create bitmap, hr %#x.\n", hr); - hr = ID2D1Bitmap_QueryInterface(bitmap, &IID_ID2D1Bitmap1, (void **)&bitmap1); - ok_(__FILE__, line)(SUCCEEDED(hr), "Failed to get ID2D1Bitmap1 interface, hr %#x.\n", hr); - - check_bitmap_surface_(line, bitmap1, has_surface, options); + check_bitmap_surface_(line, bitmap, has_surface, options); ID2D1RenderTarget_Release(compatible_rt); - ID2D1Bitmap1_Release(bitmap1); ID2D1Bitmap_Release(bitmap); } else @@ -6776,7 +6789,7 @@ if (SUCCEEDED(hr)) hr = ID2D1DeviceContext_CreateBitmapFromDxgiSurface(device_context, surface, NULL, &bitmap); ok(SUCCEEDED(hr), "Failed to create a bitmap, hr %#x.\n", hr); - check_bitmap_surface(bitmap, TRUE, D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW); + check_bitmap_surface((ID2D1Bitmap *)bitmap, TRUE, D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW); check_rt_bitmap_surface((ID2D1RenderTarget *)device_context, TRUE, D2D1_BITMAP_OPTIONS_NONE); ID2D1DeviceContext_Release(device_context); -- 2.18.0

3 6

[PATCH 1/2] include: Add d3d11on12 header.
by Józef Kucia 17 Sep '18

17 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- include/Makefile.in | 1 + include/d3d11on12.idl | 61 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 62 insertions(+) create mode 100644 include/d3d11on12.idl diff --git a/include/Makefile.in b/include/Makefile.in index 74dc293a2939..f90fe842083c 100644 --- a/include/Makefile.in +++ b/include/Makefile.in @@ -95,6 +95,7 @@ SOURCES = \ d3d11_2.idl \ d3d11_3.idl \ d3d11_4.idl \ + d3d11on12.idl \ d3d11sdklayers.idl \ d3d11shader.h \ d3d12.idl \ diff --git a/include/d3d11on12.idl b/include/d3d11on12.idl new file mode 100644 index 000000000000..5a866d7a89d6 --- /dev/null +++ b/include/d3d11on12.idl @@ -0,0 +1,61 @@ +/* + * Copyright 2018 Józef Kucia + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +import "oaidl.idl"; +import "ocidl.idl"; +import "d3d11.idl"; +import "d3d12.idl"; + +typedef struct D3D11_RESOURCE_FLAGS +{ + UINT BindFlags; + UINT MiscFlags; + UINT CPUAccessFlags; + UINT StructureByteStride; +} D3D11_RESOURCE_FLAGS; + +[ + uuid(85611e73-70a9-490e-9614-a9e302777904), + object, + local, + pointer_default(unique) +] +interface ID3D11On12Device : IUnknown +{ + HRESULT CreateWrappedResource(IUnknown *d3d12_resource, + const D3D11_RESOURCE_FLAGS *flags, + D3D12_RESOURCE_STATES input_state, + D3D12_RESOURCE_STATES output_state, + REFIID iid, void **d3d11_resource); + + void ReleaseWrappedResources(ID3D11Resource * const *resources, UINT count); + + void AcquireWrappedResources(ID3D11Resource * const *resources, UINT count); +} + +[local] HRESULT __stdcall D3D11On12CreateDevice(IUnknown *device, UINT flags, + const D3D_FEATURE_LEVEL *feature_levels, UINT feature_level_count, + IUnknown * const *queues, UINT queue_count, UINT node_mask, + ID3D11Device **d3d11_device, ID3D11DeviceContext **d3d11_immediate_context, + D3D_FEATURE_LEVEL *obtained_feature_level); + +typedef HRESULT (__stdcall *PFN_D3D11ON12_CREATE_DEVICE)(IUnknown *device, UINT FLAGS, + const D3D_FEATURE_LEVEL *feature_levels, UINT feature_level_count, + IUnknown * const *queues, UINT queue_count, UINT node_mask, + ID3D11Device **d3d11_device, ID3D11DeviceContext **d3d11_immediate_context, + D3D_FEATURE_LEVEL *obtained_feature_level); -- 2.16.4

2 1

Wrap-up of wineconf
by Hugh McMaster 17 Sep '18

17 Sep '18

Hi all, Are there any summaries or presentations from Wineconf available for those of us who couldn't attend? (And even those who could...) Hugh

5 6

[PATCH 7/7] wined3d: Cleanup get_flexible_vertex_size().
by Józef Kucia 17 Sep '18

17 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/device.c | 50 ++++++++++++++++++++++++-------------------------- 1 file changed, 24 insertions(+), 26 deletions(-) diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index 667b90b51bb5..96e7a3dbfaa6 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -3016,17 +3016,16 @@ unsigned int CDECL wined3d_device_get_max_frame_latency(const struct wined3d_dev return device->max_frame_latency; } -static DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) +static unsigned int wined3d_get_flexible_vertex_size(DWORD fvf) { - DWORD size = 0; - int i; - int numTextures = (d3dvtVertexType & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT; + unsigned int texcoord_count = (fvf & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT; + unsigned int i, size = 0; - if (d3dvtVertexType & WINED3DFVF_NORMAL) size += 3 * sizeof(float); - if (d3dvtVertexType & WINED3DFVF_DIFFUSE) size += sizeof(DWORD); - if (d3dvtVertexType & WINED3DFVF_SPECULAR) size += sizeof(DWORD); - if (d3dvtVertexType & WINED3DFVF_PSIZE) size += sizeof(DWORD); - switch (d3dvtVertexType & WINED3DFVF_POSITION_MASK) + if (fvf & WINED3DFVF_NORMAL) size += 3 * sizeof(float); + if (fvf & WINED3DFVF_DIFFUSE) size += sizeof(DWORD); + if (fvf & WINED3DFVF_SPECULAR) size += sizeof(DWORD); + if (fvf & WINED3DFVF_PSIZE) size += sizeof(DWORD); + switch (fvf & WINED3DFVF_POSITION_MASK) { case WINED3DFVF_XYZ: size += 3 * sizeof(float); break; case WINED3DFVF_XYZRHW: size += 4 * sizeof(float); break; @@ -3036,11 +3035,11 @@ static DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) case WINED3DFVF_XYZB4: size += 7 * sizeof(float); break; case WINED3DFVF_XYZB5: size += 8 * sizeof(float); break; case WINED3DFVF_XYZW: size += 4 * sizeof(float); break; - default: FIXME("Unexpected position mask %#x.\n", d3dvtVertexType & WINED3DFVF_POSITION_MASK); + default: FIXME("Unexpected position mask %#x.\n", fvf & WINED3DFVF_POSITION_MASK); } - for (i = 0; i < numTextures; i++) + for (i = 0; i < texcoord_count; ++i) { - size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float); + size += GET_TEXCOORD_SIZE_FROM_FVF(fvf, i) * sizeof(float); } return size; @@ -3049,14 +3048,13 @@ static DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) /* Context activation is done by the caller. */ #define copy_and_next(dest, src, size) memcpy(dest, src, size); dest += (size) static HRESULT process_vertices_strided(const struct wined3d_device *device, DWORD dwDestIndex, DWORD dwCount, - const struct wined3d_stream_info *stream_info, struct wined3d_buffer *dest, DWORD flags, - DWORD DestFVF) + const struct wined3d_stream_info *stream_info, struct wined3d_buffer *dest, DWORD flags, DWORD dst_fvf) { struct wined3d_matrix mat, proj_mat, view_mat, world_mat; struct wined3d_map_desc map_desc; struct wined3d_box box = {0}; struct wined3d_viewport vp; - UINT vertex_size; + unsigned int vertex_size; unsigned int i; BYTE *dest_ptr; BOOL doClip; @@ -3094,7 +3092,7 @@ static HRESULT process_vertices_strided(const struct wined3d_device *device, DWO else doClip = FALSE; - vertex_size = get_flexible_vertex_size(DestFVF); + vertex_size = wined3d_get_flexible_vertex_size(dst_fvf); box.left = dwDestIndex * vertex_size; box.right = box.left + dwCount * vertex_size; if (FAILED(hr = wined3d_resource_map(&dest->resource, 0, &map_desc, &box, WINED3D_MAP_WRITE))) @@ -3134,13 +3132,13 @@ static HRESULT process_vertices_strided(const struct wined3d_device *device, DWO multiply_matrix(&mat,&view_mat,&world_mat); multiply_matrix(&mat,&proj_mat,&mat); - numTextures = (DestFVF & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT; + numTextures = (dst_fvf & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT; for (i = 0; i < dwCount; i+= 1) { unsigned int tex_index; - if ( ((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZ ) || - ((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW ) ) { + if ( ((dst_fvf & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZ ) || + ((dst_fvf & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW ) ) { /* The position first */ const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_POSITION]; const float *p = (const float *)(element->data.addr + i * element->stride); @@ -3235,14 +3233,14 @@ static HRESULT process_vertices_strided(const struct wined3d_device *device, DWO dest_ptr += 3 * sizeof(float); - if ((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW) + if ((dst_fvf & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW) dest_ptr += sizeof(float); } - if (DestFVF & WINED3DFVF_PSIZE) + if (dst_fvf & WINED3DFVF_PSIZE) dest_ptr += sizeof(DWORD); - if (DestFVF & WINED3DFVF_NORMAL) + if (dst_fvf & WINED3DFVF_NORMAL) { const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_NORMAL]; const float *normal = (const float *)(element->data.addr + i * element->stride); @@ -3251,7 +3249,7 @@ static HRESULT process_vertices_strided(const struct wined3d_device *device, DWO copy_and_next(dest_ptr, normal, 3 * sizeof(float)); } - if (DestFVF & WINED3DFVF_DIFFUSE) + if (dst_fvf & WINED3DFVF_DIFFUSE) { const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_DIFFUSE]; const DWORD *color_d = (const DWORD *)(element->data.addr + i * element->stride); @@ -3273,7 +3271,7 @@ static HRESULT process_vertices_strided(const struct wined3d_device *device, DWO } } - if (DestFVF & WINED3DFVF_SPECULAR) + if (dst_fvf & WINED3DFVF_SPECULAR) { /* What's the color value in the feedback buffer? */ const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_SPECULAR]; @@ -3303,11 +3301,11 @@ static HRESULT process_vertices_strided(const struct wined3d_device *device, DWO if (!(stream_info->use_map & (1u << (WINED3D_FFP_TEXCOORD0 + tex_index)))) { ERR("No source texture, but destination requests one\n"); - dest_ptr += GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float); + dest_ptr += GET_TEXCOORD_SIZE_FROM_FVF(dst_fvf, tex_index) * sizeof(float); } else { - copy_and_next(dest_ptr, tex_coord, GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float)); + copy_and_next(dest_ptr, tex_coord, GET_TEXCOORD_SIZE_FROM_FVF(dst_fvf, tex_index) * sizeof(float)); } } } -- 2.16.4

2 1

[PATCH 6/7] wined3d: Move get_flexible_vertex_size() to device.c.
by Józef Kucia 17 Sep '18

17 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/device.c | 30 ++++++++++++++++++++++++++++++ dlls/wined3d/utils.c | 27 --------------------------- dlls/wined3d/wined3d_private.h | 1 - 3 files changed, 30 insertions(+), 28 deletions(-) diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index f6a0b39cecd6..667b90b51bb5 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -3016,6 +3016,36 @@ unsigned int CDECL wined3d_device_get_max_frame_latency(const struct wined3d_dev return device->max_frame_latency; } +static DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) +{ + DWORD size = 0; + int i; + int numTextures = (d3dvtVertexType & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT; + + if (d3dvtVertexType & WINED3DFVF_NORMAL) size += 3 * sizeof(float); + if (d3dvtVertexType & WINED3DFVF_DIFFUSE) size += sizeof(DWORD); + if (d3dvtVertexType & WINED3DFVF_SPECULAR) size += sizeof(DWORD); + if (d3dvtVertexType & WINED3DFVF_PSIZE) size += sizeof(DWORD); + switch (d3dvtVertexType & WINED3DFVF_POSITION_MASK) + { + case WINED3DFVF_XYZ: size += 3 * sizeof(float); break; + case WINED3DFVF_XYZRHW: size += 4 * sizeof(float); break; + case WINED3DFVF_XYZB1: size += 4 * sizeof(float); break; + case WINED3DFVF_XYZB2: size += 5 * sizeof(float); break; + case WINED3DFVF_XYZB3: size += 6 * sizeof(float); break; + case WINED3DFVF_XYZB4: size += 7 * sizeof(float); break; + case WINED3DFVF_XYZB5: size += 8 * sizeof(float); break; + case WINED3DFVF_XYZW: size += 4 * sizeof(float); break; + default: FIXME("Unexpected position mask %#x.\n", d3dvtVertexType & WINED3DFVF_POSITION_MASK); + } + for (i = 0; i < numTextures; i++) + { + size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float); + } + + return size; +} + /* Context activation is done by the caller. */ #define copy_and_next(dest, src, size) memcpy(dest, src, size); dest += (size) static HRESULT process_vertices_strided(const struct wined3d_device *device, DWORD dwDestIndex, DWORD dwCount, diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index b19f18fea45a..db27270ba8a0 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -5563,33 +5563,6 @@ void multiply_matrix(struct wined3d_matrix *dst, const struct wined3d_matrix *sr *dst = tmp; } -DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) { - DWORD size = 0; - int i; - int numTextures = (d3dvtVertexType & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT; - - if (d3dvtVertexType & WINED3DFVF_NORMAL) size += 3 * sizeof(float); - if (d3dvtVertexType & WINED3DFVF_DIFFUSE) size += sizeof(DWORD); - if (d3dvtVertexType & WINED3DFVF_SPECULAR) size += sizeof(DWORD); - if (d3dvtVertexType & WINED3DFVF_PSIZE) size += sizeof(DWORD); - switch (d3dvtVertexType & WINED3DFVF_POSITION_MASK) { - case WINED3DFVF_XYZ: size += 3 * sizeof(float); break; - case WINED3DFVF_XYZRHW: size += 4 * sizeof(float); break; - case WINED3DFVF_XYZB1: size += 4 * sizeof(float); break; - case WINED3DFVF_XYZB2: size += 5 * sizeof(float); break; - case WINED3DFVF_XYZB3: size += 6 * sizeof(float); break; - case WINED3DFVF_XYZB4: size += 7 * sizeof(float); break; - case WINED3DFVF_XYZB5: size += 8 * sizeof(float); break; - case WINED3DFVF_XYZW: size += 4 * sizeof(float); break; - default: ERR("Unexpected position mask\n"); - } - for (i = 0; i < numTextures; i++) { - size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float); - } - - return size; -} - unsigned int wined3d_max_compat_varyings(const struct wined3d_gl_info *gl_info) { /* On core profile we have to also count diffuse and specular colors and the diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index aea874f84eab..19341a59b751 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -1540,7 +1540,6 @@ void draw_primitive(struct wined3d_device *device, const struct wined3d_state *s const struct wined3d_draw_parameters *draw_parameters) DECLSPEC_HIDDEN; void dispatch_compute(struct wined3d_device *device, const struct wined3d_state *state, const struct wined3d_dispatch_parameters *dispatch_parameters) DECLSPEC_HIDDEN; -DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) DECLSPEC_HIDDEN; #define eps 1e-8f -- 2.16.4

2 1

[PATCH 5/7] wined3d: Initialise typeless formats after all formats properties are initialised.
by Józef Kucia 17 Sep '18

17 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/utils.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 0d87ffda914e..b19f18fea45a 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -3954,10 +3954,11 @@ BOOL wined3d_adapter_init_format_info(struct wined3d_adapter *adapter, struct wi apply_format_fixups(adapter, gl_info); init_format_fbo_compat_info(adapter, ctx); init_format_filter_info(adapter, gl_info); - if (!init_typeless_formats(adapter)) goto fail; init_format_gen_mipmap_info(adapter, gl_info); init_format_depth_bias_scale(adapter, ctx); + if (!init_typeless_formats(adapter)) goto fail; + return TRUE; fail: -- 2.16.4

2 1

[PATCH 2/7] wined3d: Add missing formats to debug_d3dformat().
by Józef Kucia 17 Sep '18

17 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/utils.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index b4a3c1dca291..904baef8b2dc 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -4142,6 +4142,7 @@ const char *debug_d3dformat(enum wined3d_format_id format_id) FMT_TO_STR(WINED3DFMT_R5G5_SNORM_L6_UNORM); FMT_TO_STR(WINED3DFMT_R8G8_SNORM_L8X8_UNORM); FMT_TO_STR(WINED3DFMT_R10G11B11_SNORM); + FMT_TO_STR(WINED3DFMT_R10G10B10X2_TYPELESS); FMT_TO_STR(WINED3DFMT_R10G10B10X2_UINT); FMT_TO_STR(WINED3DFMT_R10G10B10X2_SNORM); FMT_TO_STR(WINED3DFMT_R10G10B10_SNORM_A2_UNORM); @@ -4167,6 +4168,7 @@ const char *debug_d3dformat(enum wined3d_format_id format_id) FMT_TO_STR(WINED3DFMT_R8G8_SNORM_Cx); FMT_TO_STR(WINED3DFMT_ATI1N); FMT_TO_STR(WINED3DFMT_ATI2N); + FMT_TO_STR(WINED3DFMT_INST); FMT_TO_STR(WINED3DFMT_NVDB); FMT_TO_STR(WINED3DFMT_NVHU); FMT_TO_STR(WINED3DFMT_NVHS); -- 2.16.4

2 1

[PATCH 4/7] wined3d: Initialise typeless_id for typeless formats early.
by Józef Kucia 17 Sep '18

17 Sep '18

Allows us to use wined3d_format_is_typeless() while initialising formats. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/utils.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index eb4001df6e73..0d87ffda914e 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -2025,7 +2025,7 @@ static BOOL init_format_base_info(struct wined3d_adapter *adapter) for (i = 0; i < ARRAY_SIZE(typed_formats); ++i) { - const struct wined3d_format *typeless_format; + struct wined3d_format *typeless_format; unsigned int component_count = 0; DWORD flags = 0; @@ -2052,6 +2052,8 @@ static BOOL init_format_base_info(struct wined3d_adapter *adapter) format->block_byte_count = typeless_format->block_byte_count; format->typeless_id = typeless_format->id; + typeless_format->typeless_id = typeless_format->id; + for (j = 0; j < strlen(typed_formats[i].channels); ++j) { enum wined3d_channel_type channel_type = map_channel_type(typed_formats[i].channels[j]); -- 2.16.4

2 1

[PATCH 3/7] wined3d: Store additional flags directly in wined3d_format_block_info.
by Józef Kucia 17 Sep '18

17 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/utils.c | 51 ++++++++++++++++++++++----------------------------- 1 file changed, 22 insertions(+), 29 deletions(-) diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 904baef8b2dc..eb4001df6e73 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -570,31 +570,30 @@ struct wined3d_format_block_info UINT block_width; UINT block_height; UINT block_byte_count; - BOOL verify; - BOOL compressed; + unsigned int flags; }; static const struct wined3d_format_block_info format_block_info[] = { - {WINED3DFMT_DXT1, 4, 4, 8, TRUE, TRUE}, - {WINED3DFMT_DXT2, 4, 4, 16, TRUE, TRUE}, - {WINED3DFMT_DXT3, 4, 4, 16, TRUE, TRUE}, - {WINED3DFMT_DXT4, 4, 4, 16, TRUE, TRUE}, - {WINED3DFMT_DXT5, 4, 4, 16, TRUE, TRUE}, - {WINED3DFMT_BC1_UNORM, 4, 4, 8, TRUE, TRUE}, - {WINED3DFMT_BC2_UNORM, 4, 4, 16, TRUE, TRUE}, - {WINED3DFMT_BC3_UNORM, 4, 4, 16, TRUE, TRUE}, - {WINED3DFMT_BC4_UNORM, 4, 4, 8, TRUE, TRUE}, - {WINED3DFMT_BC4_SNORM, 4, 4, 8, TRUE, TRUE}, - {WINED3DFMT_BC5_UNORM, 4, 4, 16, TRUE, TRUE}, - {WINED3DFMT_BC5_SNORM, 4, 4, 16, TRUE, TRUE}, - {WINED3DFMT_BC6H_UF16, 4, 4, 16, TRUE, TRUE}, - {WINED3DFMT_BC6H_SF16, 4, 4, 16, TRUE, TRUE}, - {WINED3DFMT_BC7_UNORM, 4, 4, 16, TRUE, TRUE}, - {WINED3DFMT_ATI1N, 4, 4, 8, FALSE, TRUE}, - {WINED3DFMT_ATI2N, 4, 4, 16, FALSE, TRUE}, - {WINED3DFMT_YUY2, 2, 1, 4, FALSE, FALSE}, - {WINED3DFMT_UYVY, 2, 1, 4, FALSE, FALSE}, + {WINED3DFMT_DXT1, 4, 4, 8, WINED3DFMT_FLAG_COMPRESSED}, + {WINED3DFMT_DXT2, 4, 4, 16, WINED3DFMT_FLAG_COMPRESSED}, + {WINED3DFMT_DXT3, 4, 4, 16, WINED3DFMT_FLAG_COMPRESSED}, + {WINED3DFMT_DXT4, 4, 4, 16, WINED3DFMT_FLAG_COMPRESSED}, + {WINED3DFMT_DXT5, 4, 4, 16, WINED3DFMT_FLAG_COMPRESSED}, + {WINED3DFMT_BC1_UNORM, 4, 4, 8, WINED3DFMT_FLAG_COMPRESSED}, + {WINED3DFMT_BC2_UNORM, 4, 4, 16, WINED3DFMT_FLAG_COMPRESSED}, + {WINED3DFMT_BC3_UNORM, 4, 4, 16, WINED3DFMT_FLAG_COMPRESSED}, + {WINED3DFMT_BC4_UNORM, 4, 4, 8, WINED3DFMT_FLAG_COMPRESSED}, + {WINED3DFMT_BC4_SNORM, 4, 4, 8, WINED3DFMT_FLAG_COMPRESSED}, + {WINED3DFMT_BC5_UNORM, 4, 4, 16, WINED3DFMT_FLAG_COMPRESSED}, + {WINED3DFMT_BC5_SNORM, 4, 4, 16, WINED3DFMT_FLAG_COMPRESSED}, + {WINED3DFMT_BC6H_UF16, 4, 4, 16, WINED3DFMT_FLAG_COMPRESSED}, + {WINED3DFMT_BC6H_SF16, 4, 4, 16, WINED3DFMT_FLAG_COMPRESSED}, + {WINED3DFMT_BC7_UNORM, 4, 4, 16, WINED3DFMT_FLAG_COMPRESSED}, + {WINED3DFMT_ATI1N, 4, 4, 8, WINED3DFMT_FLAG_COMPRESSED | WINED3DFMT_FLAG_BLOCKS_NO_VERIFY}, + {WINED3DFMT_ATI2N, 4, 4, 16, WINED3DFMT_FLAG_COMPRESSED | WINED3DFMT_FLAG_BLOCKS_NO_VERIFY}, + {WINED3DFMT_YUY2, 2, 1, 4, WINED3DFMT_FLAG_BLOCKS_NO_VERIFY}, + {WINED3DFMT_UYVY, 2, 1, 4, WINED3DFMT_FLAG_BLOCKS_NO_VERIFY}, }; struct wined3d_format_vertex_info @@ -2103,23 +2102,17 @@ fail: static BOOL init_format_block_info(struct wined3d_adapter *adapter) { struct wined3d_format *format; - unsigned int flags, i; + unsigned int i; for (i = 0; i < ARRAY_SIZE(format_block_info); ++i) { if (!(format = get_format_internal(adapter, format_block_info[i].id))) return FALSE; - flags = WINED3DFMT_FLAG_BLOCKS; - if (!format_block_info[i].verify) - flags |= WINED3DFMT_FLAG_BLOCKS_NO_VERIFY; - if (format_block_info[i].compressed) - flags |= WINED3DFMT_FLAG_COMPRESSED; - format->block_width = format_block_info[i].block_width; format->block_height = format_block_info[i].block_height; format->block_byte_count = format_block_info[i].block_byte_count; - format_set_flag(format, flags); + format_set_flag(format, WINED3DFMT_FLAG_BLOCKS | format_block_info[i].flags); } return TRUE; -- 2.16.4

2 1

[PATCH 1/7] wined3d: Use get_format_internal() to get WINED3DFMT_UNKNOWN.
by Józef Kucia 17 Sep '18

17 Sep '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/utils.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 0f8ee7134bad..b4a3c1dca291 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -3982,7 +3982,7 @@ const struct wined3d_format *wined3d_get_format(const struct wined3d_adapter *ad { FIXME("Can't find format %s (%#x) in the format lookup table.\n", debug_d3dformat(format_id), format_id); - return &adapter->formats[get_format_idx(WINED3DFMT_UNKNOWN)]; + return get_format_internal(adapter, WINED3DFMT_UNKNOWN); } format = &adapter->formats[idx]; @@ -3997,7 +3997,7 @@ const struct wined3d_format *wined3d_get_format(const struct wined3d_adapter *ad FIXME("Cannot find depth/stencil typeless format %s (%#x).\n", debug_d3dformat(format_id), format_id); - return &adapter->formats[get_format_idx(WINED3DFMT_UNKNOWN)]; + return get_format_internal(adapter, WINED3DFMT_UNKNOWN); } return format; -- 2.16.4

2 1

[PATCH v2 2/2] user32/tests: Add test for desktop window procedure.
by Józef Kucia 17 Sep '18

17 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/user32/tests/msg.c | 62 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) diff --git a/dlls/user32/tests/msg.c b/dlls/user32/tests/msg.c index 55d8994023ef..28b58b678755 100644 --- a/dlls/user32/tests/msg.c +++ b/dlls/user32/tests/msg.c @@ -14963,6 +14963,67 @@ static void test_defwinproc(void) DestroyWindow( hwnd); } +static void test_desktop_winproc(void) +{ + HINSTANCE instance = GetModuleHandleA(NULL); + RECT rect, default_rect; + WNDPROC desktop_proc; + char buffer[256]; + WNDCLASSA cls; + LRESULT res; + HWND hwnd; + BOOL ret; + + ret = GetClassInfoA(instance, (const CHAR *)MAKEINTATOM(32769), &cls); + ok(ret, "Failed to get desktop class.\n"); + desktop_proc = cls.lpfnWndProc; + + memset(&cls, 0, sizeof(cls)); + cls.lpfnWndProc = desktop_proc; + cls.hInstance = instance; + cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW); + cls.hbrBackground = GetStockObject(WHITE_BRUSH); + cls.lpszClassName = "TestDesktopClass"; + ret = !!RegisterClassA(&cls); + ok(ret, "Failed to register class.\n"); + + hwnd = CreateWindowExA(0, cls.lpszClassName, "test_desktop_wndproc", + WS_VISIBLE | WS_CAPTION | WS_OVERLAPPEDWINDOW, 0, 0, 500, 100, 0, 0, 0, NULL); + if (!hwnd) /* win2003 */ + { + skip("Failed to create window with desktop window procedure.\n"); + goto out_unregister; + } + + memset(&cls, 0, sizeof(cls)); + ret = GetClassInfoA(instance, "TestDesktopClass", &cls); + ok(ret, "Failed to get class info.\n"); + ok(cls.lpfnWndProc == desktop_proc, "Got %p, expected %p.\n", cls.lpfnWndProc, desktop_proc); + + GetWindowTextA(hwnd, buffer, ARRAY_SIZE(buffer)); + todo_wine ok(!strcmp(buffer, "test_desktop_wndproc"), "Got unexpected window text: %s.\n", buffer); + + res = CallWindowProcA(desktop_proc, hwnd, WM_SETTEXT, 0, (LPARAM)"test"); + ok(res == TRUE, "Failed to set text, %ld.\n", res); + GetWindowTextA(hwnd, buffer, ARRAY_SIZE(buffer)); + ok(!strcmp(buffer, "test"), "Got unexpected window text: %s.\n", buffer); + + SetRect(&default_rect, 0, 0, 100, 100); + res = DefWindowProcW(hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&default_rect); + ok(!res, "Got unexpected result %ld.\n", res); + + SetRect(&rect, 0, 0, 100, 100); + res = CallWindowProcA(desktop_proc, hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&rect); + ok(!res, "Got unexpected result %ld.\n", res); + todo_wine ok(EqualRect(&rect, &default_rect), "rect Got %s, expected %s.\n", + wine_dbgstr_rect(&rect), wine_dbgstr_rect(&default_rect)); + + DestroyWindow(hwnd); + +out_unregister: + UnregisterClassA("TestDesktopClass", instance); +} + #define clear_clipboard(hwnd) clear_clipboard_(__LINE__, (hwnd)) static void clear_clipboard_(int line, HWND hWnd) { @@ -17108,6 +17169,7 @@ START_TEST(msg) test_menu_messages(); test_paintingloop(); test_defwinproc(); + test_desktop_winproc(); test_clipboard_viewers(); test_keyflags(); test_hotkey(); -- 2.16.4

2 1

[PATCH v2 1/2] user32: Call DefWindowProc() in DesktopWndProc().
by Józef Kucia 17 Sep '18

17 Sep '18

From: Józef Kucia <jkucia(a)codeweavers.com> This fixes a regression introduced by commit fc14753dc0188a52a05243d5d82c4062b93daaff. WM_NCCALCSIZE is not handled yet because it initiates loading the driver again. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=45485 Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- Hopefully more acceptable fix. We could fix WM_NCCALCSIZE by using one the following solutions: * call SystemParametersInfoW() only when strictly necessary in AdjustWindowRectEx(), * avoid calling user drivers in SystemParametersInfo(); the call to user driver is only necessary for SPI_GETSCREENSAVEACTIVE and SPI_SETSCREENSAVEACTIVE. I'm not sure if there are other better, preferable ways to fix WM_NCCALCSIZE. --- dlls/user32/desktop.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/dlls/user32/desktop.c b/dlls/user32/desktop.c index d22e732fd5b9..f53b3f6ec0dd 100644 --- a/dlls/user32/desktop.c +++ b/dlls/user32/desktop.c @@ -127,8 +127,9 @@ LRESULT WINAPI DesktopWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lP } return TRUE; } + case WM_NCCALCSIZE: return 0; default: - return 0; /* all other messages are ignored */ + return DefWindowProcW( hwnd, message, wParam, lParam ); } } -- 2.16.4

1 0

[PATCH 1/2] rpcrt4/tests: Add tests for delegated proxy methods.
by Zebediah Figura 17 Sep '18

17 Sep '18

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- This test may be better placed in ole32; I'm open to moving it. dlls/rpcrt4/tests/Makefile.in | 5 +- dlls/rpcrt4/tests/cstub.c | 245 ++++++++++++++++++++++++++++++++++++++++-- dlls/rpcrt4/tests/cstub.idl | 37 +++++++ 3 files changed, 280 insertions(+), 7 deletions(-) create mode 100644 dlls/rpcrt4/tests/cstub.idl diff --git a/dlls/rpcrt4/tests/Makefile.in b/dlls/rpcrt4/tests/Makefile.in index 5b80bc3..d8353b6 100644 --- a/dlls/rpcrt4/tests/Makefile.in +++ b/dlls/rpcrt4/tests/Makefile.in @@ -1,6 +1,7 @@ TESTDLL = rpcrt4.dll IMPORTS = oleaut32 ole32 rpcrt4 secur32 advapi32 EXTRAIDLFLAGS = --prefix-server=s_ +EXTRADEFS = -DPROXY_DELEGATION C_SRCS = \ cstub.c \ @@ -10,4 +11,6 @@ C_SRCS = \ rpc_async.c \ server.c -IDL_SRCS = server.idl +IDL_SRCS = \ + cstub.idl \ + server.idl diff --git a/dlls/rpcrt4/tests/cstub.c b/dlls/rpcrt4/tests/cstub.c index 7bed308..22d4569 100644 --- a/dlls/rpcrt4/tests/cstub.c +++ b/dlls/rpcrt4/tests/cstub.c @@ -19,11 +19,10 @@ */ #include <stdarg.h> +#include <stdio.h> -#define PROXY_DELEGATION #define COBJMACROS -#include "wine/test.h" #include <windef.h> #include <winbase.h> #include <winnt.h> @@ -35,10 +34,22 @@ #include "rpcdce.h" #include "rpcproxy.h" +#include "wine/heap.h" +#include "wine/test.h" + +#include "cstub.h" + static CStdPSFactoryBuffer PSFactoryBuffer; -CSTDSTUBBUFFERRELEASE(&PSFactoryBuffer) -CSTDSTUBBUFFER2RELEASE(&PSFactoryBuffer) +static ULONG WINAPI test_CStdStubBuffer_Release(IRpcStubBuffer *This) +{ + return NdrCStdStubBuffer_Release(This, (IPSFactoryBuffer *)&PSFactoryBuffer); +} + +static ULONG WINAPI test_CStdStubBuffer2_Release(IRpcStubBuffer *This) +{ + return NdrCStdStubBuffer2_Release(This, (IPSFactoryBuffer *)&PSFactoryBuffer); +} static GUID IID_if1 = {0x12345678, 1234, 5678, {12,34,56,78,90,0xab,0xcd,0xef}}; static GUID IID_if2 = {0x12345679, 1234, 5678, {12,34,56,78,90,0xab,0xcd,0xef}}; @@ -186,7 +197,18 @@ static CInterfaceStubVtbl if1_stub_vtbl = 5, &if1_table[-3] }, - { CStdStubBuffer_METHODS } + { + CStdStubBuffer_QueryInterface, + CStdStubBuffer_AddRef, + test_CStdStubBuffer_Release, + CStdStubBuffer_Connect, + CStdStubBuffer_Disconnect, + CStdStubBuffer_Invoke, + CStdStubBuffer_IsIIDSupported, + CStdStubBuffer_CountRefs, + CStdStubBuffer_DebugServerQueryInterface, + CStdStubBuffer_DebugServerRelease + } }; static CINTERFACE_PROXY_VTABLE(13) if2_proxy_vtbl = @@ -257,7 +279,7 @@ static CInterfaceStubVtbl if2_stub_vtbl = 13, &if2_table[-3] }, - { CStdStubBuffer_DELEGATING_METHODS } + { 0, 0, test_CStdStubBuffer2_Release, 0, 0, 0, 0, 0, 0, 0 } }; static CINTERFACE_PROXY_VTABLE(5) if3_proxy_vtbl = @@ -1194,9 +1216,219 @@ static void test_NdrDllRegisterProxy( void ) } } +static HANDLE create_process(const char *arg) +{ + PROCESS_INFORMATION pi; + STARTUPINFOA si = {0}; + char cmdline[200]; + char **argv; + BOOL ret; + + si.cb = sizeof(si); + winetest_get_mainargs(&argv); + sprintf(cmdline, "\"%s\" %s %s", argv[0], argv[1], arg); + ret = CreateProcessA(argv[0], cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi); + ok(ret, "CreateProcess failed: %u\n", GetLastError()); + CloseHandle(pi.hThread); + return pi.hProcess; +} + +DEFINE_GUID(CLSID_test1,0xdeadf00d,0x0001,0x44c7,0x85,0x0f,0x2a,0x0f,0x46,0x5c,0x0c,0x6c); + +static HRESULT WINAPI test1_QueryInterface(ITest1 *iface, REFIID iid, void **out) +{ + if (winetest_debug > 1) trace("%s\n", wine_dbgstr_guid(iid)); + if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_ITest1)) + { + *out = iface; + return S_OK; + } + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI test1_AddRef(ITest1 *iface) +{ + return 2; +} + +static ULONG WINAPI test1_Release(ITest1 *iface) +{ + return 1; +} + +static HRESULT WINAPI test1_GetClassID(ITest1 *iface, CLSID *clsid) +{ + *clsid = CLSID_test1; + return S_OK; +} + +static int WINAPI test1_square(ITest1 *iface, int x) +{ + return x * x; +} + +static const ITest1Vtbl test1_vtbl = +{ + test1_QueryInterface, + test1_AddRef, + test1_Release, + test1_GetClassID, + test1_square, +}; + +static HRESULT WINAPI test_cf_QueryInterface(IClassFactory *iface, REFIID iid, void **out) +{ + if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IClassFactory)) + { + *out = iface; + return S_OK; + } + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI test_cf_AddRef(IClassFactory *iface) +{ + return 2; +} + +static ULONG WINAPI test_cf_Release(IClassFactory *iface) +{ + return 1; +} + +static HRESULT WINAPI test_cf_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID iid, void **out) +{ + ITest1 *obj = heap_alloc(sizeof(*obj)); + + obj->lpVtbl = &test1_vtbl; + + return ITest1_QueryInterface(obj, iid, out); +} + +static HRESULT WINAPI test_cf_LockServer(IClassFactory *iface, BOOL lock) +{ + return S_OK; +} + +static const IClassFactoryVtbl test_cf_vtbl = +{ + test_cf_QueryInterface, + test_cf_AddRef, + test_cf_Release, + test_cf_CreateInstance, + test_cf_LockServer, +}; + +static IClassFactory test_cf = { &test_cf_vtbl }; + +extern CStdPSFactoryBuffer gPFactory; +extern const ProxyFileInfo * aProxyFileList; + +static void local_server_proc(void) +{ + DWORD obj_cookie, ps_cookie, index; + HANDLE stop_event, ready_event; + IPSFactoryBuffer *ps; + HRESULT hr; + + stop_event = OpenEventA(EVENT_ALL_ACCESS, FALSE, "wine_cstub_test_server_stop"); + ready_event = OpenEventA(EVENT_ALL_ACCESS, FALSE, "wine_cstub_test_server_ready"); + + CoInitialize(NULL); + + hr = CoRegisterClassObject(&CLSID_test1, (IUnknown *)&test_cf, + CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE, &obj_cookie); + ok(hr == S_OK, "got %#x\n", hr); + + hr = NdrDllGetClassObject(&CLSID_test_ps, &IID_IPSFactoryBuffer, (void **)&ps, + &aProxyFileList, &CLSID_test_ps, &gPFactory); + ok(hr == S_OK, "got %#x\n", hr); + + hr = CoRegisterClassObject(&CLSID_test_ps, (IUnknown *)ps, + CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &ps_cookie); + ok(hr == S_OK, "got %#x\n", hr); + + hr = CoRegisterPSClsid(&IID_ITest1, &CLSID_test_ps); + ok(hr == S_OK, "got %#x\n", hr); + + SetEvent(ready_event); + + hr = CoWaitForMultipleHandles(0, 1000, 1, &stop_event, &index); + ok(hr == S_OK, "got %#x\n", hr); + ok(!index, "got %u\n", index); + + hr = CoRevokeClassObject(ps_cookie); + ok(hr == S_OK, "got %#x\n", hr); + + hr = CoRevokeClassObject(obj_cookie); + ok(hr == S_OK, "got %#x\n", hr); + + CoUninitialize(); + ExitProcess(0); +} + +static void test_delegated_methods(void) +{ + HANDLE process, stop_event, ready_event; + IPSFactoryBuffer *ps; + ITest1 *test_obj; + DWORD ps_cookie; + CLSID clsid; + HRESULT hr; + int ret; + + stop_event = CreateEventA(NULL, TRUE, FALSE, "wine_cstub_test_server_stop"); + ready_event = CreateEventA(NULL, TRUE, FALSE, "wine_cstub_test_server_ready"); + + process = create_process("server"); + ok(!WaitForSingleObject(ready_event, 1000), "wait failed\n"); + + hr = NdrDllGetClassObject(&CLSID_test_ps, &IID_IPSFactoryBuffer, (void **)&ps, + &aProxyFileList, &CLSID_test_ps, &gPFactory); + ok(hr == S_OK, "got %#x\n", hr); + + hr = CoRegisterClassObject(&CLSID_test_ps, (IUnknown *)ps, + CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &ps_cookie); + ok(hr == S_OK, "got %#x\n", hr); + + hr = CoRegisterPSClsid(&IID_ITest1, &CLSID_test_ps); + ok(hr == S_OK, "got %#x\n", hr); + + hr = CoCreateInstance(&CLSID_test1, NULL, CLSCTX_LOCAL_SERVER, &IID_ITest1, (void **)&test_obj); + ok(hr == S_OK, "got %#x\n", hr); + + ret = ITest1_square(test_obj, 3); + ok(ret == 9, "got %d\n", ret); + + hr = ITest1_GetClassID(test_obj, &clsid); +todo_wine { + ok(hr == S_OK, "got %#x\n", hr); + ok(IsEqualGUID(&clsid, &CLSID_test1), "got %s\n", wine_dbgstr_guid(&clsid)); +} + + ITest1_Release(test_obj); + + SetEvent(stop_event); + ok(!WaitForSingleObject(process, 1000), "wait failed\n"); + + hr = CoRevokeClassObject(ps_cookie); + ok(hr == S_OK, "got %#x\n", hr); +} + START_TEST( cstub ) { IPSFactoryBuffer *ppsf; + int argc; + char **argv; + + argc = winetest_get_mainargs( &argv ); + if (argc > 2 && !strcmp(argv[2], "server")) + { + local_server_proc(); + return; + } OleInitialize(NULL); @@ -1209,6 +1441,7 @@ START_TEST( cstub ) test_Release(ppsf); test_delegating_Invoke(ppsf); test_NdrDllRegisterProxy(); + test_delegated_methods(); OleUninitialize(); } diff --git a/dlls/rpcrt4/tests/cstub.idl b/dlls/rpcrt4/tests/cstub.idl new file mode 100644 index 0000000..461bd87 --- /dev/null +++ b/dlls/rpcrt4/tests/cstub.idl @@ -0,0 +1,37 @@ +/* + * IDL to test COM object proxy/stub functions + * + * Copyright 2018 Zebediah Figura + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#pragma makedep proxy + +import "oleidl.idl"; + +[ + uuid(deadbeef-0001-44c7-850f-2a0f465c0c6c), + object +] +interface ITest1 : IPersist +{ + int square(int x); +} + +[ + uuid(deadbeef-ffff-44c7-850f-2a0f465c0c6c) +] +coclass test_ps { interface IPSFactoryBuffer; } -- 2.7.4

2 3

Re: [PATCH] ole32: Release marshal data before removing apartment from list.
by Sergio Gómez Del Real 17 Sep '18

17 Sep '18

I'm not sure how to add a test case here: The issue is in apartment_release(), but specifically when the count drops to 0 so that apartment gets destroyed. This function doesn't have a means to communicate errors when releasing resources fail while destroying apartment; it just returns a DWORD with the reference count. As far as I can tell, there isn't any call to apartment_release() that relies on the DWORD returned; we could return a special value here upon failure releasing any resource, although I don't think that would be useful in general (it would only be useful to the test case). On 12/09/18 16:40, Marvin wrote: > Thank you for your contribution to Wine! > > This is an automated notification to let you know that your patch has > been reviewed and its status set to "Needs tests". > > This means that you need to write some test cases demonstrating that > the patch is correct. > > If you do not understand the reason for this status, disagree with our > assessment, or are simply not sure how to proceed next, please ask for > clarification by replying to this email.

2 1

[PATCH v3 2/4] riched20: Add stub for ITextDocument2Old interface.
by Jactry Zeng 17 Sep '18

17 Sep '18

Superseded patch 151076. Signed-off-by: Jactry Zeng <jzeng(a)codeweavers.com> --- dlls/riched20/editor.h | 2 +- dlls/riched20/richole.c | 445 ++++++++++++++++++++++++---------- dlls/riched20/tests/richole.c | 9 + dlls/riched20/txtsrv.c | 2 +- 4 files changed, 325 insertions(+), 133 deletions(-) diff --git a/dlls/riched20/editor.h b/dlls/riched20/editor.h index 141c63aca9..eba6d35fc7 100644 --- a/dlls/riched20/editor.h +++ b/dlls/riched20/editor.h @@ -233,7 +233,7 @@ void ME_DrawOLE(ME_Context *c, int x, int y, ME_Run* run, BOOL selected) DECLSPE void ME_GetOLEObjectSize(const ME_Context *c, ME_Run *run, SIZE *pSize) DECLSPEC_HIDDEN; void ME_CopyReObject(REOBJECT *dst, const REOBJECT *src, DWORD flags) DECLSPEC_HIDDEN; void ME_DeleteReObject(struct re_object *re_object) DECLSPEC_HIDDEN; -void ME_GetITextDocumentInterface(IRichEditOle *iface, LPVOID *ppvObj) DECLSPEC_HIDDEN; +void ME_GetITextDocument2OldInterface(IRichEditOle *iface, LPVOID *ppvObj) DECLSPEC_HIDDEN; /* editor.c */ ME_TextEditor *ME_MakeEditor(ITextHost *texthost, BOOL bEmulateVersion10) DECLSPEC_HIDDEN; diff --git a/dlls/riched20/richole.c b/dlls/riched20/richole.c index 11b9920b57..8d43ce6ce1 100644 --- a/dlls/riched20/richole.c +++ b/dlls/riched20/richole.c @@ -46,6 +46,7 @@ DEFINE_GUID(IID_ITextServices, 0x8d33f740, 0xcf58, 0x11ce, 0xa8, 0x9d, 0x00, 0xa DEFINE_GUID(IID_ITextHost, 0x13e670f4,0x1a5a,0x11cf,0xab,0xeb,0x00,0xaa,0x00,0xb6,0x5e,0xa1); DEFINE_GUID(IID_ITextHost2, 0x13e670f5,0x1a5a,0x11cf,0xab,0xeb,0x00,0xaa,0x00,0xb6,0x5e,0xa1); DEFINE_GUID(IID_ITextDocument, 0x8cc497c0, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d); +DEFINE_GUID(IID_ITextDocument2Old, 0x01c25500, 0x4268, 0x11d1, 0x88, 0x3a, 0x3c, 0x8b, 0x00, 0xc1, 0x00, 0x00); DEFINE_GUID(IID_ITextRange, 0x8cc497c2, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d); DEFINE_GUID(IID_ITextSelection, 0x8cc497c1, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d); DEFINE_GUID(IID_ITextFont, 0x8cc497c3, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d); @@ -55,7 +56,7 @@ static ITypeLib *typelib; enum tid_t { NULL_tid, - ITextDocument_tid, + ITextDocument2Old_tid, ITextRange_tid, ITextSelection_tid, ITextFont_tid, @@ -66,7 +67,7 @@ enum tid_t { static const IID * const tid_ids[] = { &IID_NULL, - &IID_ITextDocument, + &IID_ITextDocument2Old, &IID_ITextRange, &IID_ITextSelection, &IID_ITextFont, @@ -208,7 +209,7 @@ enum range_update_op { typedef struct IRichEditOleImpl { IUnknown IUnknown_inner; IRichEditOle IRichEditOle_iface; - ITextDocument ITextDocument_iface; + ITextDocument2Old ITextDocument2Old_iface; IUnknown *outer_unk; LONG ref; @@ -267,9 +268,9 @@ static inline IRichEditOleImpl *impl_from_IRichEditOle(IRichEditOle *iface) return CONTAINING_RECORD(iface, IRichEditOleImpl, IRichEditOle_iface); } -static inline IRichEditOleImpl *impl_from_ITextDocument(ITextDocument *iface) +static inline IRichEditOleImpl *impl_from_ITextDocument2Old(ITextDocument2Old *iface) { - return CONTAINING_RECORD(iface, IRichEditOleImpl, ITextDocument_iface); + return CONTAINING_RECORD(iface, IRichEditOleImpl, ITextDocument2Old_iface); } static inline IRichEditOleImpl *impl_from_IUnknown(IUnknown *iface) @@ -943,8 +944,8 @@ static HRESULT WINAPI IRichEditOleImpl_inner_fnQueryInterface(IUnknown *iface, R *ppvObj = &This->IUnknown_inner; else if (IsEqualGUID(riid, &IID_IRichEditOle)) *ppvObj = &This->IRichEditOle_iface; - else if (IsEqualGUID(riid, &IID_ITextDocument)) - *ppvObj = &This->ITextDocument_iface; + else if (IsEqualGUID(riid, &IID_ITextDocument) || IsEqualGUID(riid, &IID_ITextDocument2Old)) + *ppvObj = &This->ITextDocument2Old_iface; if (*ppvObj) { IUnknown_AddRef((IUnknown *)*ppvObj); @@ -3859,76 +3860,71 @@ static HRESULT create_textpara(ITextRange *range, ITextPara **ret) } /* ITextDocument */ -static HRESULT WINAPI -ITextDocument_fnQueryInterface(ITextDocument* me, REFIID riid, - void** ppvObject) +static HRESULT WINAPI ITextDocument2Old_fnQueryInterface(ITextDocument2Old* iface, REFIID riid, + void **ppvObject) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); return IRichEditOle_QueryInterface(&This->IRichEditOle_iface, riid, ppvObject); } -static ULONG WINAPI -ITextDocument_fnAddRef(ITextDocument* me) +static ULONG WINAPI ITextDocument2Old_fnAddRef(ITextDocument2Old *iface) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); return IRichEditOle_AddRef(&This->IRichEditOle_iface); } -static ULONG WINAPI -ITextDocument_fnRelease(ITextDocument* me) +static ULONG WINAPI ITextDocument2Old_fnRelease(ITextDocument2Old *iface) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); return IRichEditOle_Release(&This->IRichEditOle_iface); } -static HRESULT WINAPI -ITextDocument_fnGetTypeInfoCount(ITextDocument* me, - UINT* pctinfo) +static HRESULT WINAPI ITextDocument2Old_fnGetTypeInfoCount(ITextDocument2Old *iface, + UINT *pctinfo) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); TRACE("(%p)->(%p)\n", This, pctinfo); *pctinfo = 1; return S_OK; } -static HRESULT WINAPI -ITextDocument_fnGetTypeInfo(ITextDocument* me, UINT iTInfo, LCID lcid, - ITypeInfo** ppTInfo) +static HRESULT WINAPI ITextDocument2Old_fnGetTypeInfo(ITextDocument2Old *iface, UINT iTInfo, LCID lcid, + ITypeInfo **ppTInfo) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); HRESULT hr; TRACE("(%p)->(%u,%d,%p)\n", This, iTInfo, lcid, ppTInfo); - hr = get_typeinfo(ITextDocument_tid, ppTInfo); + hr = get_typeinfo(ITextDocument2Old_tid, ppTInfo); if (SUCCEEDED(hr)) ITypeInfo_AddRef(*ppTInfo); return hr; } -static HRESULT WINAPI -ITextDocument_fnGetIDsOfNames(ITextDocument* me, REFIID riid, - LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId) +static HRESULT WINAPI ITextDocument2Old_fnGetIDsOfNames(ITextDocument2Old *iface, REFIID riid, + LPOLESTR *rgszNames, UINT cNames, + LCID lcid, DISPID *rgDispId) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); ITypeInfo *ti; HRESULT hr; TRACE("(%p)->(%s, %p, %u, %d, %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId); - hr = get_typeinfo(ITextDocument_tid, &ti); + hr = get_typeinfo(ITextDocument2Old_tid, &ti); if (SUCCEEDED(hr)) hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId); return hr; } -static HRESULT WINAPI -ITextDocument_fnInvoke(ITextDocument* me, DISPID dispIdMember, - REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, - VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr) +static HRESULT WINAPI ITextDocument2Old_fnInvoke(ITextDocument2Old *iface, DISPID dispIdMember, + REFIID riid, LCID lcid, WORD wFlags, + DISPPARAMS *pDispParams, VARIANT *pVarResult, + EXCEPINFO *pExcepInfo, UINT *puArgErr) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); ITypeInfo *ti; HRESULT hr; @@ -3936,26 +3932,24 @@ ITextDocument_fnInvoke(ITextDocument* me, DISPID dispIdMember, debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); - hr = get_typeinfo(ITextDocument_tid, &ti); + hr = get_typeinfo(ITextDocument2Old_tid, &ti); if (SUCCEEDED(hr)) - hr = ITypeInfo_Invoke(ti, me, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + hr = ITypeInfo_Invoke(ti, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); return hr; } -static HRESULT WINAPI -ITextDocument_fnGetName(ITextDocument* me, BSTR* pName) +static HRESULT WINAPI ITextDocument2Old_fnGetName(ITextDocument2Old *iface, BSTR *pName) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); FIXME("stub %p\n",This); return E_NOTIMPL; } -static HRESULT WINAPI -ITextDocument_fnGetSelection(ITextDocument *me, ITextSelection **selection) +static HRESULT WINAPI ITextDocument2Old_fnGetSelection(ITextDocument2Old *iface, ITextSelection **selection) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); - TRACE("(%p)->(%p)\n", me, selection); + TRACE("(%p)->(%p)\n", iface, selection); if (!selection) return E_INVALIDARG; @@ -3973,125 +3967,110 @@ ITextDocument_fnGetSelection(ITextDocument *me, ITextSelection **selection) return S_OK; } -static HRESULT WINAPI -ITextDocument_fnGetStoryCount(ITextDocument* me, LONG* pCount) +static HRESULT WINAPI ITextDocument2Old_fnGetStoryCount(ITextDocument2Old *iface, LONG *pCount) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); FIXME("stub %p\n",This); return E_NOTIMPL; } -static HRESULT WINAPI -ITextDocument_fnGetStoryRanges(ITextDocument* me, - ITextStoryRanges** ppStories) +static HRESULT WINAPI ITextDocument2Old_fnGetStoryRanges(ITextDocument2Old *iface, + ITextStoryRanges **ppStories) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); FIXME("stub %p\n",This); return E_NOTIMPL; } -static HRESULT WINAPI -ITextDocument_fnGetSaved(ITextDocument* me, LONG* pValue) +static HRESULT WINAPI ITextDocument2Old_fnGetSaved(ITextDocument2Old *iface, LONG *pValue) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); FIXME("stub %p\n",This); return E_NOTIMPL; } -static HRESULT WINAPI -ITextDocument_fnSetSaved(ITextDocument* me, LONG Value) +static HRESULT WINAPI ITextDocument2Old_fnSetSaved(ITextDocument2Old *iface, LONG Value) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); FIXME("stub %p\n",This); return E_NOTIMPL; } -static HRESULT WINAPI -ITextDocument_fnGetDefaultTabStop(ITextDocument* me, float* pValue) +static HRESULT WINAPI ITextDocument2Old_fnGetDefaultTabStop(ITextDocument2Old *iface, float *pValue) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); FIXME("stub %p\n",This); return E_NOTIMPL; } -static HRESULT WINAPI -ITextDocument_fnSetDefaultTabStop(ITextDocument* me, float Value) +static HRESULT WINAPI ITextDocument2Old_fnSetDefaultTabStop(ITextDocument2Old *iface, float Value) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); FIXME("stub %p\n",This); return E_NOTIMPL; } -static HRESULT WINAPI -ITextDocument_fnNew(ITextDocument* me) +static HRESULT WINAPI ITextDocument2Old_fnNew(ITextDocument2Old *iface) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); FIXME("stub %p\n",This); return E_NOTIMPL; } -static HRESULT WINAPI -ITextDocument_fnOpen(ITextDocument* me, VARIANT* pVar, LONG Flags, - LONG CodePage) +static HRESULT WINAPI ITextDocument2Old_fnOpen(ITextDocument2Old *iface, VARIANT *pVar, + LONG Flags, LONG CodePage) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); FIXME("stub %p\n",This); return E_NOTIMPL; } -static HRESULT WINAPI -ITextDocument_fnSave(ITextDocument* me, VARIANT* pVar, LONG Flags, - LONG CodePage) +static HRESULT WINAPI ITextDocument2Old_fnSave(ITextDocument2Old *iface, VARIANT *pVar, + LONG Flags, LONG CodePage) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); FIXME("stub %p\n",This); return E_NOTIMPL; } -static HRESULT WINAPI -ITextDocument_fnFreeze(ITextDocument* me, LONG* pCount) +static HRESULT WINAPI ITextDocument2Old_fnFreeze(ITextDocument2Old *iface, LONG *pCount) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); FIXME("stub %p\n",This); return E_NOTIMPL; } -static HRESULT WINAPI -ITextDocument_fnUnfreeze(ITextDocument* me, LONG* pCount) +static HRESULT WINAPI ITextDocument2Old_fnUnfreeze(ITextDocument2Old *iface, LONG *pCount) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); FIXME("stub %p\n",This); return E_NOTIMPL; } -static HRESULT WINAPI -ITextDocument_fnBeginEditCollection(ITextDocument* me) +static HRESULT WINAPI ITextDocument2Old_fnBeginEditCollection(ITextDocument2Old *iface) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); FIXME("stub %p\n",This); return E_NOTIMPL; } -static HRESULT WINAPI -ITextDocument_fnEndEditCollection(ITextDocument* me) +static HRESULT WINAPI ITextDocument2Old_fnEndEditCollection(ITextDocument2Old *iface) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); FIXME("stub %p\n",This); return E_NOTIMPL; } -static HRESULT WINAPI -ITextDocument_fnUndo(ITextDocument* me, LONG Count, LONG* prop) +static HRESULT WINAPI ITextDocument2Old_fnUndo(ITextDocument2Old *iface, LONG Count, LONG *prop) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); FIXME("stub %p\n",This); return E_NOTIMPL; } -static HRESULT WINAPI -ITextDocument_fnRedo(ITextDocument* me, LONG Count, LONG* prop) +static HRESULT WINAPI ITextDocument2Old_fnRedo(ITextDocument2Old *iface, LONG Count, LONG *prop) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); FIXME("stub %p\n",This); return E_NOTIMPL; } @@ -4112,11 +4091,10 @@ static HRESULT CreateITextRange(IRichEditOleImpl *reOle, LONG start, LONG end, I return S_OK; } -static HRESULT WINAPI -ITextDocument_fnRange(ITextDocument* me, LONG cp1, LONG cp2, - ITextRange** ppRange) +static HRESULT WINAPI ITextDocument2Old_fnRange(ITextDocument2Old *iface, LONG cp1, LONG cp2, + ITextRange **ppRange) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); const int len = ME_GetTextLength(This->editor) + 1; TRACE("%p %p %d %d\n", This, ppRange, cp1, cp2); @@ -4140,42 +4118,247 @@ ITextDocument_fnRange(ITextDocument* me, LONG cp1, LONG cp2, return CreateITextRange(This, cp1, cp2, ppRange); } -static HRESULT WINAPI -ITextDocument_fnRangeFromPoint(ITextDocument* me, LONG x, LONG y, - ITextRange** ppRange) +static HRESULT WINAPI ITextDocument2Old_fnRangeFromPoint(ITextDocument2Old *iface, LONG x, LONG y, + ITextRange **ppRange) { - IRichEditOleImpl *This = impl_from_ITextDocument(me); + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); FIXME("stub %p\n",This); return E_NOTIMPL; } -static const ITextDocumentVtbl tdvt = { - ITextDocument_fnQueryInterface, - ITextDocument_fnAddRef, - ITextDocument_fnRelease, - ITextDocument_fnGetTypeInfoCount, - ITextDocument_fnGetTypeInfo, - ITextDocument_fnGetIDsOfNames, - ITextDocument_fnInvoke, - ITextDocument_fnGetName, - ITextDocument_fnGetSelection, - ITextDocument_fnGetStoryCount, - ITextDocument_fnGetStoryRanges, - ITextDocument_fnGetSaved, - ITextDocument_fnSetSaved, - ITextDocument_fnGetDefaultTabStop, - ITextDocument_fnSetDefaultTabStop, - ITextDocument_fnNew, - ITextDocument_fnOpen, - ITextDocument_fnSave, - ITextDocument_fnFreeze, - ITextDocument_fnUnfreeze, - ITextDocument_fnBeginEditCollection, - ITextDocument_fnEndEditCollection, - ITextDocument_fnUndo, - ITextDocument_fnRedo, - ITextDocument_fnRange, - ITextDocument_fnRangeFromPoint +/* ITextDocument2Old methods */ +static HRESULT WINAPI ITextDocument2Old_fnAttachMsgFilter(ITextDocument2Old *iface, IUnknown *filter) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(%p): stub\n", This, filter); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnSetEffectColor(ITextDocument2Old *iface, LONG index, COLORREF cr) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(%d, 0x%x): stub\n", This, index, cr); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnGetEffectColor(ITextDocument2Old *iface, LONG index, COLORREF *cr) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(%d, %p): stub\n", This, index, cr); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnGetCaretType(ITextDocument2Old *iface, LONG *type) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(%p): stub\n", This, type); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnSetCaretType(ITextDocument2Old *iface, LONG type) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(%d): stub\n", This, type); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnGetImmContext(ITextDocument2Old *iface, LONG *context) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(%p): stub\n", This, context); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnReleaseImmContext(ITextDocument2Old *iface, LONG context) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(%d): stub\n", This, context); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnGetPreferredFont(ITextDocument2Old *iface, LONG cp, LONG charrep, + LONG options, LONG current_charrep, LONG current_fontsize, + BSTR *bstr, LONG *pitch_family, LONG *new_fontsize) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(%d, %d, %d, %d, %d, %p, %p, %p): stub\n", This, cp, charrep, options, current_charrep, + current_fontsize, bstr, pitch_family, new_fontsize); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnGetNotificationMode(ITextDocument2Old *iface, LONG *mode) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(%p): stub\n", This, mode); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnSetNotificationMode(ITextDocument2Old *iface, LONG mode) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(0x%x): stub\n", This, mode); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnGetClientRect(ITextDocument2Old *iface, LONG type, LONG *left, LONG *top, + LONG *right, LONG *bottom) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(%d, %p, %p, %p, %p): stub\n", This, type, left, top, right, bottom); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnGetSelectionEx(ITextDocument2Old *iface, ITextSelection **selection) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(%p): stub\n", This, selection); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnGetWindow(ITextDocument2Old *iface, LONG *hwnd) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(%p): stub\n", This, hwnd); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnGetFEFlags(ITextDocument2Old *iface, LONG *flags) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(%p): stub\n", This, flags); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnUpdateWindow(ITextDocument2Old *iface) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p): stub\n", This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnCheckTextLimit(ITextDocument2Old *iface, LONG cch, LONG *exceed) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(%d, %p): stub\n", This, cch, exceed); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnIMEInProgress(ITextDocument2Old *iface, LONG mode) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(0x%x): stub\n", This, mode); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnSysBeep(ITextDocument2Old *iface) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p): stub\n", This); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnUpdate(ITextDocument2Old *iface, LONG mode) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(0x%x): stub\n", This, mode); + + return E_NOTIMPL; +} + +static HRESULT WINAPI ITextDocument2Old_fnNotify(ITextDocument2Old *iface, LONG notify) +{ + IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface); + + FIXME("(%p)->(%d): stub\n", This, notify); + + return E_NOTIMPL; +} + +static const ITextDocument2OldVtbl tdvt = { + ITextDocument2Old_fnQueryInterface, + ITextDocument2Old_fnAddRef, + ITextDocument2Old_fnRelease, + ITextDocument2Old_fnGetTypeInfoCount, + ITextDocument2Old_fnGetTypeInfo, + ITextDocument2Old_fnGetIDsOfNames, + ITextDocument2Old_fnInvoke, + ITextDocument2Old_fnGetName, + ITextDocument2Old_fnGetSelection, + ITextDocument2Old_fnGetStoryCount, + ITextDocument2Old_fnGetStoryRanges, + ITextDocument2Old_fnGetSaved, + ITextDocument2Old_fnSetSaved, + ITextDocument2Old_fnGetDefaultTabStop, + ITextDocument2Old_fnSetDefaultTabStop, + ITextDocument2Old_fnNew, + ITextDocument2Old_fnOpen, + ITextDocument2Old_fnSave, + ITextDocument2Old_fnFreeze, + ITextDocument2Old_fnUnfreeze, + ITextDocument2Old_fnBeginEditCollection, + ITextDocument2Old_fnEndEditCollection, + ITextDocument2Old_fnUndo, + ITextDocument2Old_fnRedo, + ITextDocument2Old_fnRange, + ITextDocument2Old_fnRangeFromPoint, + /* ITextDocument2Old methods */ + ITextDocument2Old_fnAttachMsgFilter, + ITextDocument2Old_fnSetEffectColor, + ITextDocument2Old_fnGetEffectColor, + ITextDocument2Old_fnGetCaretType, + ITextDocument2Old_fnSetCaretType, + ITextDocument2Old_fnGetImmContext, + ITextDocument2Old_fnReleaseImmContext, + ITextDocument2Old_fnGetPreferredFont, + ITextDocument2Old_fnGetNotificationMode, + ITextDocument2Old_fnSetNotificationMode, + ITextDocument2Old_fnGetClientRect, + ITextDocument2Old_fnGetSelectionEx, + ITextDocument2Old_fnGetWindow, + ITextDocument2Old_fnGetFEFlags, + ITextDocument2Old_fnUpdateWindow, + ITextDocument2Old_fnCheckTextLimit, + ITextDocument2Old_fnIMEInProgress, + ITextDocument2Old_fnSysBeep, + ITextDocument2Old_fnUpdate, + ITextDocument2Old_fnNotify }; /* ITextSelection */ @@ -5276,7 +5459,7 @@ LRESULT CreateIRichEditOle(IUnknown *outer_unk, ME_TextEditor *editor, LPVOID *p reo->IUnknown_inner.lpVtbl = &reo_unk_vtbl; reo->IRichEditOle_iface.lpVtbl = &revt; - reo->ITextDocument_iface.lpVtbl = &tdvt; + reo->ITextDocument2Old_iface.lpVtbl = &tdvt; reo->ref = 1; reo->editor = editor; reo->txtSel = NULL; @@ -5509,8 +5692,8 @@ void ME_CopyReObject(REOBJECT *dst, const REOBJECT *src, DWORD flags) } } -void ME_GetITextDocumentInterface(IRichEditOle *iface, LPVOID *ppvObj) +void ME_GetITextDocument2OldInterface(IRichEditOle *iface, LPVOID *ppvObj) { IRichEditOleImpl *This = impl_from_IRichEditOle(iface); - *ppvObj = &This->ITextDocument_iface; + *ppvObj = &This->ITextDocument2Old_iface; } diff --git a/dlls/riched20/tests/richole.c b/dlls/riched20/tests/richole.c index aaf52bcfdd..3e42047a57 100644 --- a/dlls/riched20/tests/richole.c +++ b/dlls/riched20/tests/richole.c @@ -117,6 +117,7 @@ static void test_Interfaces(void) { IRichEditOle *reOle = NULL, *reOle1 = NULL; ITextDocument *txtDoc = NULL; + ITextDocument2Old *txtDoc2Old = NULL; ITextSelection *txtSel = NULL, *txtSel2; IUnknown *punk; HRESULT hres; @@ -195,6 +196,14 @@ static void test_Interfaces(void) hres = IRichEditOle_QueryInterface(reOle, &IID_IOleInPlaceSite, (void **) &punk); ok(hres == E_NOINTERFACE, "IRichEditOle_QueryInterface\n"); + hres = IRichEditOle_QueryInterface(reOle, &IID_ITextDocument2Old, (void **)&txtDoc2Old); + ok(hres == S_OK, "IRichEditOle_QueryInterface\n"); + ok(txtDoc2Old != NULL, "IRichEditOle_QueryInterface\n"); + ok((ITextDocument *)txtDoc2Old == txtDoc, "interface pointer isn't equal.\n"); + EXPECT_REF(txtDoc2Old, 5); + EXPECT_REF(reOle, 5); + ITextDocument2Old_Release(txtDoc2Old); + ITextDocument_Release(txtDoc); IRichEditOle_Release(reOle); refcount = IRichEditOle_Release(reOle); diff --git a/dlls/riched20/txtsrv.c b/dlls/riched20/txtsrv.c index ee65621b1d..5ab3322e6b 100644 --- a/dlls/riched20/txtsrv.c +++ b/dlls/riched20/txtsrv.c @@ -83,7 +83,7 @@ static HRESULT WINAPI ITextServicesImpl_QueryInterface(IUnknown *iface, REFIID r if (!CreateIRichEditOle(This->outer_unk, This->editor, (void **)(&This->editor->reOle))) return E_OUTOFMEMORY; if (IsEqualIID(riid, &IID_ITextDocument)) - ME_GetITextDocumentInterface(This->editor->reOle, ppv); + ME_GetITextDocument2OldInterface(This->editor->reOle, ppv); else *ppv = This->editor->reOle; } else { -- 2.18.0

3 2

[PATCH] winhttp: Make winsock_init() static.
by Francois Gouget 17 Sep '18

17 Sep '18

Signed-off-by: Francois Gouget <fgouget(a)free.fr> --- dlls/winhttp/net.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/winhttp/net.c b/dlls/winhttp/net.c index c141185cf8f..020ec5b04bc 100644 --- a/dlls/winhttp/net.c +++ b/dlls/winhttp/net.c @@ -167,7 +167,7 @@ static BOOL WINAPI winsock_startup( INIT_ONCE *once, void *param, void **ctx ) return TRUE; } -void winsock_init(void) +static void winsock_init(void) { static INIT_ONCE once = INIT_ONCE_STATIC_INIT; InitOnceExecuteOnce( &once, winsock_startup, NULL, NULL ); -- 2.18.0

2 1

[PATCH] msxml3/tests: Make test_namespaces_as_attributes() static.
by Francois Gouget 17 Sep '18

17 Sep '18

Signed-off-by: Francois Gouget <fgouget(a)free.fr> --- dlls/msxml3/tests/domdoc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/msxml3/tests/domdoc.c b/dlls/msxml3/tests/domdoc.c index b602e030a8b..b7b29e332d0 100644 --- a/dlls/msxml3/tests/domdoc.c +++ b/dlls/msxml3/tests/domdoc.c @@ -12847,7 +12847,7 @@ static const namespace_as_attribute_t namespace_as_attribute_test_data[] = { { 0 } }; -void test_namespaces_as_attributes(void) +static void test_namespaces_as_attributes(void) { const namespace_as_attribute_t *entry = namespace_as_attribute_test_data; static const char ns_as_attr_doc[] = { -- 2.18.0

2 1

[PATCH] opcservices: Add missing break (coverity)
by Fabian Maurer 17 Sep '18

17 Sep '18

Signed-off-by: Fabian Maurer <dark.shadow4(a)web.de> --- dlls/opcservices/package.c | 1 + 1 file changed, 1 insertion(+) diff --git a/dlls/opcservices/package.c b/dlls/opcservices/package.c index eb9c1c9f5a..f3503945b5 100644 --- a/dlls/opcservices/package.c +++ b/dlls/opcservices/package.c @@ -607,6 +607,7 @@ static HRESULT WINAPI opc_content_stream_Seek(IStream *iface, LARGE_INTEGER move break; case STREAM_SEEK_END: pos.QuadPart = stream->content->size.QuadPart + move.QuadPart; + break; default: WARN("Unknown origin mode %d.\n", origin); return E_INVALIDARG; -- 2.19.0

2 1

Re: [PATCH] scrrun: Add MoveFile().
by Nikolay Sivov 17 Sep '18

17 Sep '18

On 09/16/2018 04:48 PM, Fabian Maurer wrote: > > + TRACE("%p %s %s\n", iface, debugstr_w(src), debugstr_w(dest)); > > > + > > > + if (MoveFileW(src, dest)) > > > + return S_OK; > > > + > > > + error = GetLastError(); > > > + switch (error) > > > + { > > > + case ERROR_ALREADY_EXISTS: > > > + return CTL_E_FILEALREADYEXISTS; > > > + case ERROR_FILE_NOT_FOUND: > > > + return CTL_E_FILENOTFOUND; > > > + default: > > > + return HRESULT_FROM_WIN32(error); > > > + } > > That doesn't seem quite correct. > > As the docs I linked from > https://bugs.winehq.org/show_bug.cgi?id=45839 state, this function > also accepts wildcards. On my win7 machine that works, but MoveFileW > can't handle this. > Should still work for reported case. I can add a warning with arguments for error case if you think it helps. > Regards, > > Fabian Maurer >

3 2

[PATCH] xmllite/writer: Fix "xml:space" output.
by Nikolay Sivov 17 Sep '18

17 Sep '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/xmllite/tests/writer.c | 14 ++++++++++++++ dlls/xmllite/writer.c | 29 +++++++++++++++++++++++++++++ 2 files changed, 43 insertions(+) diff --git a/dlls/xmllite/tests/writer.c b/dlls/xmllite/tests/writer.c index 7f731be211..2cd9cea6cc 100644 --- a/dlls/xmllite/tests/writer.c +++ b/dlls/xmllite/tests/writer.c @@ -1637,6 +1637,12 @@ static void test_WriteAttributeString(void) { "prefix", "xmlns", "uri", "", "<e prefix:xmlns=\"\" xmlns:prefix=\"uri\" />", "<e prefix:xmlns=\"\"" }, { "prefix", "xmlns", NULL, "uri", "<e xmlns=\"uri\" />", "<e xmlns=\"uri\"" }, { "prefix", "xmlns", "", "uri", "<e xmlns=\"uri\" />", "<e xmlns=\"uri\"" }, + { "xml", "space", NULL, "preserve", "<e xml:space=\"preserve\" />", "<e xml:space=\"preserve\"" }, + { "xml", "space", "", "preserve", "<e xml:space=\"preserve\" />", "<e xml:space=\"preserve\"" }, + { "xml", "space", NULL, "default", "<e xml:space=\"default\" />", "<e xml:space=\"default\"" }, + { "xml", "space", "", "default", "<e xml:space=\"default\" />", "<e xml:space=\"default\"" }, + { "xml", "a", NULL, "value", "<e xml:a=\"value\" />", "<e xml:a=\"value\"" }, + { "xml", "a", "", "value", "<e xml:a=\"value\" />", "<e xml:a=\"value\"" }, /* Autogenerated prefix names. */ { NULL, "a", "defuri", NULL, "<e p1:a=\"\" xmlns:p1=\"defuri\" />", "<e p1:a=\"\"", S_OK, 1, 1, 1 }, @@ -1655,6 +1661,7 @@ static void test_WriteAttributeString(void) { "prefix", NULL, "http://www.w3.org/2000/xmlns/", "defuri", "<e />", "<e", E_INVALIDARG }, { "prefix", NULL, NULL, "b", "<e />", "<e", E_INVALIDARG }, { "prefix", NULL, "uri", NULL, "<e />", "<e", E_INVALIDARG }, + { "xml", NULL, NULL, "value", "<e />", "<e", E_INVALIDARG }, { "xmlns", "a", "defuri", NULL, "<e />", "<e", WR_E_XMLNSPREFIXDECLARATION }, { "xmlns", "a", "b", "uri", "<e />", "<e", WR_E_XMLNSPREFIXDECLARATION }, { NULL, "xmlns", "uri", NULL, "<e />", "<e", WR_E_XMLNSPREFIXDECLARATION, 0, 0, 1 }, @@ -1666,6 +1673,13 @@ static void test_WriteAttributeString(void) { "xmlns", NULL, "", "uri", "<e />", "<e", WR_E_NSPREFIXDECLARED }, { "xmlns", "", NULL, "uri", "<e />", "<e", WR_E_NSPREFIXDECLARED }, { "xmlns", "", "", "uri", "<e />", "<e", WR_E_NSPREFIXDECLARED }, + { "xml", "space", "", "value", "<e />", "<e", WR_E_INVALIDXMLSPACE }, + { "xml", "space", NULL, "value", "<e />", "<e", WR_E_INVALIDXMLSPACE }, + { "xml", "a", "uri", "value", "<e />", "<e", WR_E_XMLPREFIXDECLARATION }, + { "xml", "space", NULL, "preServe", "<e />", "<e", WR_E_INVALIDXMLSPACE }, + { "xml", "space", NULL, "defAult", "<e />", "<e", WR_E_INVALIDXMLSPACE }, + { "xml", "space", NULL, NULL, "<e />", "<e", WR_E_INVALIDXMLSPACE }, + { "xml", "space", NULL, "", "<e />", "<e", WR_E_INVALIDXMLSPACE }, }; IXmlWriter *writer; diff --git a/dlls/xmllite/writer.c b/dlls/xmllite/writer.c index e9ad941365..bf2a7514ac 100644 --- a/dlls/xmllite/writer.c +++ b/dlls/xmllite/writer.c @@ -825,10 +825,23 @@ static void write_output_attribute(xmlwriter *writer, const WCHAR *prefix, int p write_output_buffer_quoted(writer->output, value, -1); } +static BOOL is_valid_xml_space_value(const WCHAR *value) +{ + static const WCHAR preserveW[] = {'p','r','e','s','e','r','v','e',0}; + static const WCHAR defaultW[] = {'d','e','f','a','u','l','t',0}; + + if (!value) + return FALSE; + + return !strcmpW(value, preserveW) || !strcmpW(value, defaultW); +} + static HRESULT WINAPI xmlwriter_WriteAttributeString(IXmlWriter *iface, LPCWSTR prefix, LPCWSTR local, LPCWSTR uri, LPCWSTR value) { + static const WCHAR spaceattrW[] = {'s','p','a','c','e',0}; static const WCHAR xmlnsW[] = {'x','m','l','n','s',0}; + static const WCHAR xmlW[] = {'x','m','l',0}; xmlwriter *This = impl_from_IXmlWriter(iface); int prefix_len, local_len; BOOL is_xmlns_prefix; @@ -873,6 +886,22 @@ static HRESULT WINAPI xmlwriter_WriteAttributeString(IXmlWriter *iface, LPCWSTR return S_OK; } + /* Predefined "xml" prefix. */ + if (prefix_len && !strcmpW(prefix, xmlW)) + { + /* Valid "space" value is enforced. */ + if (!strcmpW(local, spaceattrW) && !is_valid_xml_space_value(value)) + return WR_E_INVALIDXMLSPACE; + + /* Redefinition is not allowed. */ + if (!is_empty_string(uri)) + return WR_E_XMLPREFIXDECLARATION; + + write_output_attribute(This, prefix, prefix_len, local, local_len, value); + + return S_OK; + } + if (is_xmlns_prefix || (prefix_len == 0 && uri && !strcmpW(uri, xmlnsuriW))) { if (prefix_len && !is_empty_string(uri)) -- 2.18.0

1 0

[PATCH v2] winemac: Allow Command to be mapped to Ctrl.
by Ricky Zhou 17 Sep '18

17 Sep '18

Adds the following registry options, which configure the Mac driver to map Command to Ctrl: HKEY_CURRENT_USER\Software\Wine\Mac Driver\LeftCommandIsCtrl HKEY_CURRENT_USER\Software\Wine\Mac Driver\RightCommandIsCtrl Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=35351 Signed-off-by: Ricky Zhou <ricky(a)rzhou.org> --- v2: Fix comment, add warning about making it impossible to send Alt. --- dlls/winemac.drv/cocoa_window.m | 37 +++++++++++++++++++-------------- dlls/winemac.drv/macdrv_cocoa.h | 2 ++ dlls/winemac.drv/macdrv_main.c | 12 +++++++++++ 3 files changed, 35 insertions(+), 16 deletions(-) diff --git a/dlls/winemac.drv/cocoa_window.m b/dlls/winemac.drv/cocoa_window.m index 4143d147df..e405cda2d2 100644 --- a/dlls/winemac.drv/cocoa_window.m +++ b/dlls/winemac.drv/cocoa_window.m @@ -140,22 +140,27 @@ static inline void fix_generic_modifiers_by_device(NSUInteger* modifiers) *modifiers &= ~NX_ALTERNATEMASK; } -static inline NSUInteger adjusted_modifiers_for_option_behavior(NSUInteger modifiers) +static inline NSUInteger adjusted_modifiers_for_settings(NSUInteger modifiers) { fix_device_modifiers_by_generic(&modifiers); - if (left_option_is_alt && (modifiers & NX_DEVICELALTKEYMASK)) - { - modifiers |= NX_DEVICELCMDKEYMASK; - modifiers &= ~NX_DEVICELALTKEYMASK; - } - if (right_option_is_alt && (modifiers & NX_DEVICERALTKEYMASK)) - { - modifiers |= NX_DEVICERCMDKEYMASK; - modifiers &= ~NX_DEVICERALTKEYMASK; - } - fix_generic_modifiers_by_device(&modifiers); - - return modifiers; + NSUInteger new_modifiers = modifiers & ~(NX_DEVICELALTKEYMASK | NX_DEVICERALTKEYMASK | + NX_DEVICELCMDKEYMASK | NX_DEVICERCMDKEYMASK); + + // The MACDRV keyboard driver translates Command keys to Alt. If the + // Option key (NX_DEVICE[LR]ALTKEYMASK) should behave like Alt in + // Windows, rewrite it to Command (NX_DEVICE[LR]CMDKEYMASK). + if (modifiers & NX_DEVICELALTKEYMASK) + new_modifiers |= left_option_is_alt ? NX_DEVICELCMDKEYMASK : NX_DEVICELALTKEYMASK; + if (modifiers & NX_DEVICERALTKEYMASK) + new_modifiers |= right_option_is_alt ? NX_DEVICERCMDKEYMASK : NX_DEVICERALTKEYMASK; + + if (modifiers & NX_DEVICELCMDKEYMASK) + new_modifiers |= left_command_is_ctrl ? NX_DEVICELCTLKEYMASK : NX_DEVICELCMDKEYMASK; + if (modifiers & NX_DEVICERCMDKEYMASK) + new_modifiers |= right_command_is_ctrl ? NX_DEVICERCTLKEYMASK : NX_DEVICERCMDKEYMASK; + + fix_generic_modifiers_by_device(&new_modifiers); + return new_modifiers; } @@ -2059,7 +2064,7 @@ - (void) postKeyEvent:(NSEvent *)theEvent [self flagsChanged:theEvent]; [self postKey:[theEvent keyCode] pressed:[theEvent type] == NSKeyDown - modifiers:adjusted_modifiers_for_option_behavior([theEvent modifierFlags]) + modifiers:adjusted_modifiers_for_settings([theEvent modifierFlags]) event:theEvent]; } @@ -2679,7 +2684,7 @@ - (void) flagsChanged:(NSEvent *)theEvent { NX_DEVICERCMDKEYMASK, kVK_RightCommand }, }; - NSUInteger modifierFlags = adjusted_modifiers_for_option_behavior([theEvent modifierFlags]); + NSUInteger modifierFlags = adjusted_modifiers_for_settings([theEvent modifierFlags]); NSUInteger changed; int i, last_changed; diff --git a/dlls/winemac.drv/macdrv_cocoa.h b/dlls/winemac.drv/macdrv_cocoa.h index 6bad7903f6..011b1ffd37 100644 --- a/dlls/winemac.drv/macdrv_cocoa.h +++ b/dlls/winemac.drv/macdrv_cocoa.h @@ -159,6 +159,8 @@ extern int capture_displays_for_fullscreen DECLSPEC_HIDDEN; extern int left_option_is_alt DECLSPEC_HIDDEN; extern int right_option_is_alt DECLSPEC_HIDDEN; +extern int left_command_is_ctrl DECLSPEC_HIDDEN; +extern int right_command_is_ctrl DECLSPEC_HIDDEN; extern int allow_immovable_windows DECLSPEC_HIDDEN; extern int cursor_clipping_locks_windows DECLSPEC_HIDDEN; extern int use_precise_scrolling DECLSPEC_HIDDEN; diff --git a/dlls/winemac.drv/macdrv_main.c b/dlls/winemac.drv/macdrv_main.c index 7abeea9db8..544d448f9f 100644 --- a/dlls/winemac.drv/macdrv_main.c +++ b/dlls/winemac.drv/macdrv_main.c @@ -52,6 +52,8 @@ BOOL allow_vsync = TRUE; BOOL allow_set_gamma = TRUE; int left_option_is_alt = 0; int right_option_is_alt = 0; +int left_command_is_ctrl = 0; +int right_command_is_ctrl = 0; BOOL allow_software_rendering = FALSE; BOOL disable_window_decorations = FALSE; int allow_immovable_windows = TRUE; @@ -172,6 +174,16 @@ static void setup_options(void) if (!get_config_key(hkey, appkey, "RightOptionIsAlt", buffer, sizeof(buffer))) right_option_is_alt = IS_OPTION_TRUE(buffer[0]); + if (!get_config_key(hkey, appkey, "LeftCommandIsCtrl", buffer, sizeof(buffer))) + left_command_is_ctrl = IS_OPTION_TRUE(buffer[0]); + if (!get_config_key(hkey, appkey, "RightCommandIsCtrl", buffer, sizeof(buffer))) + right_command_is_ctrl = IS_OPTION_TRUE(buffer[0]); + + if (left_command_is_ctrl && right_command_is_ctrl && !left_option_is_alt && !right_option_is_alt) + WARN("Both Command keys have been mapped to Control. There is no way to " + "send an Alt key to Windows applications. Consider enabling " + "LeftOptionIsAlt or RightOptionIsAlt.\n"); + if (!get_config_key(hkey, appkey, "AllowSoftwareRendering", buffer, sizeof(buffer))) allow_software_rendering = IS_OPTION_TRUE(buffer[0]); -- 2.18.0

2 1

[PATCH] mfplat: Add MFCopyImage stub
by Alistair Leslie-Hughes 17 Sep '18

17 Sep '18

Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/mfplat/main.c | 5 +++++ dlls/mfplat/mfplat.spec | 2 +- include/mfapi.h | 1 + 3 files changed, 7 insertions(+), 1 deletion(-) diff --git a/dlls/mfplat/main.c b/dlls/mfplat/main.c index de3926f..41d5818 100644 --- a/dlls/mfplat/main.c +++ b/dlls/mfplat/main.c @@ -442,6 +442,11 @@ HRESULT WINAPI MFShutdown(void) return S_OK; } +HRESULT WINAPI MFCopyImage(BYTE *dest, long deststride, const BYTE *src, long srcstride, DWORD width, DWORD lines) +{ + FIXME("(%p, %ld, %p, %ld, %d, %d) stub\n", dest, deststride, src, srcstride, width, lines); + return E_NOTIMPL; +} typedef struct _mfbytestream { diff --git a/dlls/mfplat/mfplat.spec b/dlls/mfplat/mfplat.spec index 1ab2826..3e42d2f 100644 --- a/dlls/mfplat/mfplat.spec +++ b/dlls/mfplat/mfplat.spec @@ -35,7 +35,7 @@ @ stub MFConvertColorInfoToDXVA @ stub MFConvertFromFP16Array @ stub MFConvertToFP16Array -@ stub MFCopyImage +@ stdcall MFCopyImage(ptr long ptr long long long) @ stub MFCreateAMMediaTypeFromMFMediaType @ stub MFCreateAlignedMemoryBuffer @ stub MFCreateAsyncResult diff --git a/include/mfapi.h b/include/mfapi.h index 45449b1..e4f1220 100644 --- a/include/mfapi.h +++ b/include/mfapi.h @@ -64,6 +64,7 @@ DEFINE_GUID(MFMediaType_Video, 0x73646976, 0x0000, 0x0010, 0x80, 0x00, 0 typedef unsigned __int64 MFWORKITEM_KEY; HRESULT WINAPI MFCancelWorkItem(MFWORKITEM_KEY key); +HRESULT WINAPI MFCopyImage(BYTE *dest, long deststride, const BYTE *src, long srcstride, DWORD width, DWORD lines); HRESULT WINAPI MFCreateAttributes(IMFAttributes **attributes, UINT32 size); HRESULT WINAPI MFCreateEventQueue(IMFMediaEventQueue **queue); HRESULT WINAPI MFCreateMediaType(IMFMediaType **type); -- 1.9.1

1 0

[PATCH v3 2/2] kernel32/tests: tests for ProcessCookie in NtQueryInformationProcess.
by Alistair Leslie-Hughes 16 Sep '18

16 Sep '18

Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/kernel32/tests/process.c | 49 ++++++++++++++++++++++++++++++------------- 1 file changed, 34 insertions(+), 15 deletions(-) diff --git a/dlls/kernel32/tests/process.c b/dlls/kernel32/tests/process.c index 0eb113b..cb4f007 100644 --- a/dlls/kernel32/tests/process.c +++ b/dlls/kernel32/tests/process.c @@ -3461,7 +3461,7 @@ static void test_session_info(void) trace("active_session = %x\n", active_session); } -static void test_process_info(void) +static void test_process_info(HANDLE hproc) { char buf[4096]; static const ULONG info_size[] = @@ -3502,7 +3502,7 @@ static void test_process_info(void) sizeof(ULONG) /* ProcessIoPriority */, sizeof(ULONG) /* ProcessExecuteFlags */, 0 /* FIXME: sizeof(?) ProcessTlsInformation */, - 0 /* FIXME: sizeof(?) ProcessCookie */, + sizeof(ULONG) /* ProcessCookie */, sizeof(SECTION_IMAGE_INFORMATION) /* ProcessImageInformation */, 0 /* FIXME: sizeof(PROCESS_CYCLE_TIME_INFORMATION) ProcessCycleTime */, sizeof(ULONG) /* ProcessPagePriority */, @@ -3541,22 +3541,16 @@ static void test_process_info(void) sizeof(PROCESS_JOB_MEMORY_INFO) /* ProcessJobMemoryInformation */, #endif }; - HANDLE hproc; ULONG i, status, ret_len, size; + BOOL is_current = hproc == GetCurrentProcess(); if (!pNtQueryInformationProcess) { + CloseHandle(hproc); win_skip("NtQueryInformationProcess is not available on this platform\n"); return; } - hproc = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, GetCurrentProcessId()); - if (!hproc) - { - win_skip("PROCESS_QUERY_LIMITED_INFORMATION is not supported on this platform\n"); - return; - } - for (i = 0; i < MaxProcessInfoClass; i++) { size = info_size[i]; @@ -3598,17 +3592,33 @@ static void test_process_info(void) ok(status == STATUS_ACCESS_DENIED || status == STATUS_PORT_NOT_SET, "for info %u expected STATUS_ACCESS_DENIED, got %08x (ret_len %u)\n", i, status, ret_len); break; - + case ProcessCookie: + if (is_current) + ok(status == STATUS_SUCCESS || status == STATUS_INVALID_PARAMETER /* before win8 */, + "for info %u got %08x (ret_len %u)\n", i, status, ret_len); + else + ok(status == STATUS_INVALID_PARAMETER /* before win8 */ || status == STATUS_ACCESS_DENIED, + "for info %u got %08x (ret_len %u)\n", i, status, ret_len); + break; case ProcessExecuteFlags: case ProcessDebugPort: case ProcessDebugFlags: - case ProcessCookie: + if (is_current) + ok(status == STATUS_SUCCESS || status == STATUS_INVALID_PARAMETER, + "for info %u, got %08x (ret_len %u)\n", i, status, ret_len); + else todo_wine - ok(status == STATUS_ACCESS_DENIED, "for info %u expected STATUS_ACCESS_DENIED, got %08x (ret_len %u)\n", i, status, ret_len); + ok(status == STATUS_ACCESS_DENIED, + "for info %u expected STATUS_ACCESS_DENIED, got %08x (ret_len %u)\n", i, status, ret_len); break; default: - ok(status == STATUS_ACCESS_DENIED, "for info %u expected STATUS_ACCESS_DENIED, got %08x (ret_len %u)\n", i, status, ret_len); + if (is_current) + ok(status == STATUS_SUCCESS || status == STATUS_UNSUCCESSFUL || status == STATUS_INVALID_PARAMETER, + "for info %u, got %08x (ret_len %u)\n", i, status, ret_len); + else + ok(status == STATUS_ACCESS_DENIED, + "for info %u expected STATUS_ACCESS_DENIED, got %08x (ret_len %u)\n", i, status, ret_len); break; } } @@ -3780,6 +3790,7 @@ static void test_ProcThreadAttributeList(void) START_TEST(process) { HANDLE job; + HANDLE hproc; BOOL b = init(); ok(b, "Basic init of CreateProcess test\n"); if (!b) return; @@ -3824,7 +3835,15 @@ START_TEST(process) return; } - test_process_info(); + hproc = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, GetCurrentProcessId()); + if (hproc) + { + test_process_info(hproc); + } + else + win_skip("PROCESS_QUERY_LIMITED_INFORMATION is not supported on this platform\n"); + test_process_info(GetCurrentProcess()); + test_TerminateProcess(); test_Startup(); test_CommandLine(); -- 1.9.1

1 0

[PATCH v3 1/2] ntdll: Stub for ProcessCookie in NtQueryInformationProcess.
by Alistair Leslie-Hughes 16 Sep '18

16 Sep '18

From: Andrew Wesie <awesie(a)gmail.com> Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/ntdll/process.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/dlls/ntdll/process.c b/dlls/ntdll/process.c index b299287..c5057da 100644 --- a/dlls/ntdll/process.c +++ b/dlls/ntdll/process.c @@ -572,6 +572,22 @@ NTSTATUS WINAPI NtQueryInformationProcess( else ret = STATUS_INFO_LENGTH_MISMATCH; break; + case ProcessCookie: + FIXME("ProcessCookie (%p,%p,0x%08x,%p) stub\n", + ProcessHandle,ProcessInformation, + ProcessInformationLength,ReturnLength); + + if(ProcessHandle == NtCurrentProcess()) + { + len = sizeof(ULONG); + if (ProcessInformationLength == len) + *(ULONG *)ProcessInformation = 0; + else + ret = STATUS_INFO_LENGTH_MISMATCH; + } + else + ret = STATUS_INVALID_PARAMETER; + break; default: FIXME("(%p,info_class=%d,%p,0x%08x,%p) Unknown information class\n", ProcessHandle,ProcessInformationClass, -- 1.9.1

1 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel