June 2022 - Wine-Devel - list.winehq.org

[PATCH vkd3d 1/6] vkd3d-shader/hlsl: Fold constant swizzles.

by Giovanni Mascellani

From: Zebediah Figura <zfigura(a)codeweavers.com> Signed-off-by: Giovanni Mascellani <gmascellani(a)codeweavers.com> --- libs/vkd3d-shader/hlsl.h | 3 ++- libs/vkd3d-shader/hlsl_codegen.c | 3 ++- libs/vkd3d-shader/hlsl_constant_ops.c | 31 ++++++++++++++++++++++++++- 3 files changed, 34 insertions(+), 3 deletions(-) diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index 28b2ff1b..3c1dd08d 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -800,7 +800,8 @@ bool hlsl_offset_from_deref(struct hlsl_ctx *ctx, const struct hlsl_deref *deref unsigned int hlsl_offset_from_deref_safe(struct hlsl_ctx *ctx, const struct hlsl_deref *deref); struct hlsl_reg hlsl_reg_from_deref(struct hlsl_ctx *ctx, const struct hlsl_deref *deref); -bool hlsl_fold_constants(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context); +bool hlsl_fold_constant_exprs(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context); +bool hlsl_fold_constant_swizzles(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context); bool hlsl_sm1_register_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_semantic *semantic, bool output, D3DSHADER_PARAM_REGISTER_TYPE *type, unsigned int *reg); diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c index 1a5e9055..bc7f0a62 100644 --- a/libs/vkd3d-shader/hlsl_codegen.c +++ b/libs/vkd3d-shader/hlsl_codegen.c @@ -1946,7 +1946,8 @@ int hlsl_emit_bytecode(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry transform_ir(ctx, lower_casts_to_bool, body, NULL); do { - progress = transform_ir(ctx, hlsl_fold_constants, body, NULL); + progress = transform_ir(ctx, hlsl_fold_constant_exprs, body, NULL); + progress |= transform_ir(ctx, hlsl_fold_constant_swizzles, body, NULL); progress |= copy_propagation_execute(ctx, body); progress |= transform_ir(ctx, remove_trivial_swizzles, body, NULL); } diff --git a/libs/vkd3d-shader/hlsl_constant_ops.c b/libs/vkd3d-shader/hlsl_constant_ops.c index d8787c21..64067397 100644 --- a/libs/vkd3d-shader/hlsl_constant_ops.c +++ b/libs/vkd3d-shader/hlsl_constant_ops.c @@ -369,7 +369,7 @@ static bool fold_mod(struct hlsl_ctx *ctx, struct hlsl_ir_constant *dst, return true; } -bool hlsl_fold_constants(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) +bool hlsl_fold_constant_exprs(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) { struct hlsl_ir_constant *arg1, *arg2 = NULL, *res; struct hlsl_ir_expr *expr; @@ -447,3 +447,32 @@ bool hlsl_fold_constants(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void } return success; } + +bool hlsl_fold_constant_swizzles(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) +{ + struct hlsl_ir_constant *value, *res; + struct hlsl_ir_swizzle *swizzle; + unsigned int i, swizzle_bits; + + if (instr->type != HLSL_IR_SWIZZLE) + return false; + swizzle = hlsl_ir_swizzle(instr); + if (swizzle->val.node->type != HLSL_IR_CONSTANT) + return false; + value = hlsl_ir_constant(swizzle->val.node); + + if (!(res = hlsl_alloc(ctx, sizeof(*res)))) + return false; + init_node(&res->node, HLSL_IR_CONSTANT, instr->data_type, instr->loc); + + swizzle_bits = swizzle->swizzle; + for (i = 0; i < swizzle->node.data_type->dimx; ++i) + { + res->value[i] = value->value[swizzle_bits & 3]; + swizzle_bits >>= 2; + } + + list_add_before(&swizzle->node.entry, &res->node.entry); + hlsl_replace_node(&swizzle->node, &res->node); + return true; +} -- 2.36.1

June 27, 2022

Re: [PATCH v8 0/9] MR6: Avoid performance degradation due to vDSO unmapping (BZ#52313)

by Kevin Puetz (＠puetzk)

Another interesting case in this same area is qemu-user emulation. As you say, right now wine-preloader just uses MAP_FIXED and removes anything in its way (potentially including the vdso of ASLR put it in the way). When running under qemu-user CPU emulation, this can mean we not only remove the vdso from the process being launched (a performance degradation), but also clobber it out from under the qemu-user emulator hosting the wine-preloader process - which is in fact in the midst of a call to mmap that is *using* the vdso, so the emulator then segfaults before returning (intermittently, since ASLR doesn't always put the vdso in the way, but often enough I have seen it hit the in[0x7ffffe000000, +0x01ff0000 range](https://gitlab.winehq.org/wine/wine/-/blob/master/loader/preloader.c… I'm just remapping it won't fix that problem (having it move mid-call is going to be just as fatal as unmapping it), but it potentially makes it more tractable. qemu is already holding some separation/tagging of host vs guest, so maybe it could special case mremap to move it for us but retain it for its own purposes. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/6#note_2780

June 27, 2022

Re: [PATCH v2 0/1] MR312: winex11.drv: Increment configure_serial in X11DRV_WindowPosChanged() even if... - closed

by Paul Gofman (＠gofman)

This merge request was closed by Paul Gofman. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/312

June 27, 2022

Re: [PATCH v2 0/1] MR312: winex11.drv: Increment configure_serial in X11DRV_WindowPosChanged() even if...

by Paul Gofman (＠gofman)

After some discussion with Rémi it looks more complicated than this: at least configure_serial should be incremented when the request which will queue the event is issued. I am closing this MR for now. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/312#note_2779

June 27, 2022

Re: [PATCH 0/5] MR322: winex11.drv: Preparation for nulldrv display modes.

by Zhiyi Zhang (＠zhiyi)

On Mon Jun 27 13:55:18 2022 +0000, Rémi Bernon wrote: > In > https://gitlab.winehq.org/rbernon/wine/-/commit/88bbeaeadad09ddac679e402a2c… > I intend to enumerate display modes at the same time as display devices. > This makes sure the desktop mode handler is set to enumerate virtual > desktop modes before calling X11DRV_DisplayDevices_Init. I see. I think it's better to put this commit before that one then. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/322#note_2778

June 27, 2022

[PATCH v2 1/1] riched20/tests: Test for ITextDocument::Undo and ITextDocument::Redo.

by Jinoh Kang

From: Jinoh Kang <jinoh.kang.kr(a)gmail.com> Signed-off-by: Jinoh Kang <jinoh.kang.kr(a)gmail.com> --- dlls/riched20/tests/richole.c | 467 ++++++++++++++++++++++++++++++++++ 1 file changed, 467 insertions(+) diff --git a/dlls/riched20/tests/richole.c b/dlls/riched20/tests/richole.c index 6a361bc3fa4..9cd5931e82c 100644 --- a/dlls/riched20/tests/richole.c +++ b/dlls/riched20/tests/richole.c @@ -4955,6 +4955,471 @@ static void test_clipboard(void) ITextRange_Release(range); } +static void subtest_undo(const char *dummy_text) +{ + static const char *text_seq[] = { + "", + "1-alpha", + "2-beta", + "3-gamma", + "4-delta", + "5-epsilon", + "6-zeta", + "7-eta", + }; + static LONG seq[] = { -1, -2, -3, -1, 1, 2, 3, 1, -5, 2, -1, 3, 1, 0 }; + LONG i = 0, stack_pos = 0; + IRichEditOle *reole = NULL; + ITextDocument *doc = NULL; + ITextSelection *selection; + char buffer[1024] = ""; + HRESULT hr; + HWND hwnd; + LONG count = 0; + + winetest_push_context("(%Iu)", dummy_text ? strlen(dummy_text) : 0); + + create_interfaces(&hwnd, &reole, &doc, &selection); + + for (i = -2; i <= 2; i++) + { + if (i != tomFalse && i != tomTrue) + { + hr = ITextDocument_Undo(doc, i, NULL); + todo_wine + ok(hr == (i >= 1 ? S_OK : S_FALSE), "(%ld(a)0) Undo: %#lx\n", i, hr); + + count = 0xcccccccc; + hr = ITextDocument_Undo(doc, i, &count); + todo_wine + ok(hr == (i >= 1 ? S_OK : S_FALSE), "(%ld(a)0) Undo: %#lx\n", i, hr); + todo_wine + ok(count == (i >= 1 ? i : 0), "(%ld(a)0) Expected %ld, got %ld\n", i, i >= 0 ? i : 0, count); + } + + hr = ITextDocument_Redo(doc, i, NULL); + todo_wine + ok(hr == (i == 0 ? S_OK : S_FALSE), "(%ld(a)0) Redo: %#lx\n", i, hr); + + count = 0xcccccccc; + hr = ITextDocument_Redo(doc, i, &count); + todo_wine + ok(hr == (i == 0 ? S_OK : S_FALSE), "(%ld(a)0) Redo: %#lx\n", i, hr); + todo_wine + ok(count == 0, "(%ld(a)0) got %ld\n", i, count); + } + + while (stack_pos < ARRAY_SIZE(text_seq) - 1) + { + stack_pos++; + if (dummy_text) + { + hr = ITextDocument_Undo(doc, tomSuspend, NULL); + todo_wine + ok(hr == S_FALSE, "(@%ld) Undo: %#lx\n", stack_pos, hr); + if (SUCCEEDED(hr)) + { + SendMessageA(hwnd, EM_SETSEL, (WPARAM)0, (LPARAM)0); + SendMessageA(hwnd, EM_REPLACESEL, TRUE, (LPARAM)dummy_text); + SendMessageA(hwnd, EM_SETSEL, (WPARAM)0, (LPARAM)strlen(dummy_text)); + SendMessageA(hwnd, EM_REPLACESEL, TRUE, (LPARAM)""); + hr = ITextDocument_Undo(doc, tomResume, NULL); + todo_wine + ok(hr == S_FALSE, "(@%ld) Undo: %#lx\n", stack_pos, hr); + } + } + SendMessageA(hwnd, EM_SETSEL, (WPARAM)0, (LPARAM)-1); + SendMessageA(hwnd, EM_REPLACESEL, TRUE, (LPARAM)text_seq[stack_pos]); + } + + for (i = 0; i < ARRAY_SIZE(seq); i++) + { + LONG expect_count; + + memset(buffer, 0, sizeof(buffer)); + SendMessageA(hwnd, WM_GETTEXT, ARRAY_SIZE(buffer), (LPARAM)buffer); + todo_wine_if(stack_pos != ARRAY_SIZE(text_seq) - 1) + ok(strcmp(buffer, text_seq[stack_pos]) == 0, "Expected %s, got %s\n", + wine_dbgstr_a(text_seq[stack_pos]), wine_dbgstr_a(buffer)); + + if (!seq[i]) break; + + count = 0xcccccccc; + expect_count = labs(stack_pos - min(max(stack_pos + seq[i], 0), (LONG)ARRAY_SIZE(seq) - 1)); + if (seq[i] < 0) + { + hr = ITextDocument_Undo(doc, -seq[i], &count); + todo_wine + ok(hr == S_OK, "(%ld@%ld) Undo: %#lx\n", i, stack_pos, hr); + todo_wine + ok(count == expect_count, "(%ld@%ld) Expected %ld, got %ld\n", i, stack_pos, expect_count, count); + stack_pos -= count; + } + else + { + hr = ITextDocument_Redo(doc, seq[i], &count); + todo_wine + ok(hr == (expect_count ? S_OK : S_FALSE), "(%ld@%ld) Redo: %#lx\n", i, stack_pos, hr); + todo_wine + ok(count == expect_count, "(%ld@%ld) Expected %ld, got %ld\n", i, stack_pos, expect_count, count); + stack_pos += count; + } + + if (FAILED(hr) || count <= 0) break; + } + + release_interfaces(&hwnd, &reole, &doc, &selection); + winetest_pop_context(); +} + +static void test_undo(void) +{ + subtest_undo(NULL); + subtest_undo("dummy 12345"); +} + +#define ok_msg_result(h,m,w,l,r) ok_msg_result_(__LINE__,#m,h,m,w,l,r) +static void ok_msg_result_(int line, const char *desc, HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam, LRESULT expect) +{ + LRESULT lresult = SendMessageA(hwnd, message, wparam, lparam); + ok_(__FILE__,line)(lresult == expect, "%s: Expected %Id, got %Id\n", desc, expect, lresult); +} + +enum editorUndoState { + firstUndoState = 0, + undoStateActive = 0, + undoStateSuspended = 1, + undoStateDisabled = 2, + numUndoStates = 3, +}; + +enum editorUndoStateAction { + firstUndoAction = 0, + undoActionNoOp = 0, + undoActionEnable = 1, + undoActionDisable = 2, + undoActionSuspend = 3, + undoActionResume = 4, + numUndoActions = 5 +}; + +enum editorUndoStateTestFlags { + undoTestUseWindowMessages = 0x1, + undoTestResetUndoLimit = 0x2, + undoTestDoFirstUndo = 0x4, + undoTestDoFirstRedo = 0x8, + undoTestMaxFlag = 0x10, +}; + +static const unsigned char undo_control_state_transitions[numUndoStates][numUndoActions] = { + /* undoStateActive */ + { + undoStateActive, /* undoActionNoOp */ + undoStateActive, /* undoActionEnable */ + undoStateDisabled, /* undoActionDisable */ + undoStateSuspended, /* undoActionSuspend */ + undoStateActive /* undoActionResume */ + }, + /* undoStateSuspended */ + { + undoStateSuspended, /* undoActionNoOp */ + undoStateSuspended, /* undoActionEnable */ + undoStateDisabled, /* undoActionDisable */ + undoStateSuspended, /* undoActionSuspend */ + undoStateActive /* undoActionResume */ + }, + /* undoStateDisabled */ + { + undoStateDisabled, /* undoActionNoOp */ + undoStateActive, /* undoActionEnable */ + undoStateDisabled, /* undoActionDisable */ + undoStateDisabled, /* undoActionSuspend */ + undoStateActive /* undoActionResume */ + } +}; + +struct undo_test +{ + HWND hwnd; + ITextDocument *doc; + int test_flags; + LONG_PTR undo_limit; + BOOL undo_status; + BOOL redo_status; +}; + +static HRESULT perform_editor_undo_state_action(struct undo_test *inst, enum editorUndoStateAction action, LONG *count) +{ + HRESULT hr = S_OK; + + if (count) *count = 0xcccccccc; + + switch (action) + { + case undoActionNoOp: + if (count) *count = 0; + break; + case undoActionEnable: + if (inst->test_flags & undoTestResetUndoLimit) + { + LONG_PTR cur_undo_limit = SendMessageA(inst->hwnd, EM_SETUNDOLIMIT, inst->undo_limit, 0); + ok(cur_undo_limit == inst->undo_limit, "Expected undo limit %Id, got %Id\n", + inst->undo_limit, cur_undo_limit); + if (count) *count = 0; + } + else + { + hr = ITextDocument_Undo(inst->doc, tomTrue, count); + todo_wine + ok(hr == S_FALSE, "Undo: %#lx\n", hr); + } + inst->undo_status = TRUE; + break; + case undoActionDisable: + hr = ITextDocument_Undo(inst->doc, tomFalse, count); + todo_wine + ok(hr == S_OK, "Undo: %#lx\n", hr); + inst->undo_status = FALSE; + inst->redo_status = FALSE; + break; + case undoActionSuspend: + hr = ITextDocument_Undo(inst->doc, tomSuspend, count); + todo_wine + ok(hr == S_FALSE, "Undo: %#lx\n", hr); + break; + case undoActionResume: + hr = ITextDocument_Undo(inst->doc, tomResume, count); + todo_wine + ok(hr == S_FALSE, "Undo: %#lx\n", hr); + break; + default: + ok(0, "unreachable\n"); + break; + } + + if (count) + { + todo_wine + ok(*count == 0, "Got %ld\n", *count); + } + return hr; +} + +static HRESULT set_editor_undo_state(struct undo_test *inst, enum editorUndoState state) +{ + HRESULT hr = S_OK; + switch (state) + { + case undoStateActive: + if (FAILED(hr = perform_editor_undo_state_action(inst, undoActionEnable, NULL))) break; + if (FAILED(hr = perform_editor_undo_state_action(inst, undoActionResume, NULL))) break; + break; + case undoStateSuspended: + if (FAILED(hr = perform_editor_undo_state_action(inst, undoActionEnable, NULL))) break; + if (FAILED(hr = perform_editor_undo_state_action(inst, undoActionSuspend, NULL))) break; + break; + case undoStateDisabled: + if (FAILED(hr = perform_editor_undo_state_action(inst, undoActionDisable, NULL))) break; + break; + default: + ok(0, "unreachable\n"); + break; + } + todo_wine + ok(SUCCEEDED(hr), "cannot set state to %d: %#lx\n", undoStateActive, hr); + return hr; +} + +static BOOL perform_undo(struct undo_test *inst) +{ + LONG count; + HRESULT hr; + LRESULT lres; + + if (inst->test_flags & undoTestUseWindowMessages) + { + lres = SendMessageA(inst->hwnd, EM_UNDO, 0, 0); + ok(lres == FALSE || lres == TRUE, "unexpected LRESULT %#Ix\n", lres); + return lres; + } + + count = 0xcccccccc; + hr = ITextDocument_Undo(inst->doc, 1, &count); + todo_wine + ok(SUCCEEDED(hr), "got hr %#lx\n", hr); + todo_wine + ok(count == (hr == S_OK), "expected count %d, got %ld\n", hr == S_OK, count); + return hr == S_OK && count > 0; +} + +static BOOL perform_redo(struct undo_test *inst) +{ + LONG count; + HRESULT hr; + LRESULT lres; + + if (inst->test_flags & undoTestUseWindowMessages) + { + lres = SendMessageA(inst->hwnd, EM_REDO, 0, 0); + ok(lres == FALSE || lres == TRUE, "unexpected LRESULT %#Ix\n", lres); + return lres; + } + + count = 0xcccccccc; + hr = ITextDocument_Redo(inst->doc, 1, &count); + todo_wine + ok(SUCCEEDED(hr), "got hr %#lx\n", hr); + todo_wine + ok(count == (hr == S_OK), "expected count %d, got %ld\n", hr == S_OK, count); + return hr == S_OK && count > 0; +} + +static HRESULT subtest_undo_control(struct undo_test *inst, + enum editorUndoState from_state, + enum editorUndoStateAction action, + enum editorUndoState *to_state_ptr) +{ + enum editorUndoState to_state; + LONG undo_count, redo_count, count; + static const char text_foo[] = "foo"; + static const char text_bar[] = "bar"; + static const char *last_text, *last_text2; + char buffer[1024] = ""; + BOOL result; + HRESULT hr; + + SendMessageA(inst->hwnd, EM_EMPTYUNDOBUFFER, 0, 0); + undo_count = redo_count = 0; + ok_msg_result(inst->hwnd, EM_CANUNDO, 0, 0, undo_count > 0); + ok_msg_result(inst->hwnd, EM_CANREDO, 0, 0, redo_count > 0); + + SendMessageA(inst->hwnd, WM_SETTEXT, 0, (LPARAM)(last_text = "")); + SendMessageA(inst->hwnd, WM_GETTEXT, ARRAY_SIZE(buffer), (LPARAM)buffer); + last_text = ""; + ok(strcmp(buffer, last_text) == 0, + "Expected %s, got %s\n", wine_dbgstr_a(""), wine_dbgstr_a(buffer)); + + SendMessageA(inst->hwnd, EM_SETSEL, 0, -1); + SendMessageA(inst->hwnd, EM_REPLACESEL, TRUE, (LPARAM)(last_text = text_foo)); + undo_count += from_state == undoStateActive; + ok_msg_result(inst->hwnd, EM_CANUNDO, 0, 0, undo_count > 0); + ok_msg_result(inst->hwnd, EM_CANREDO, 0, 0, redo_count > 0); + SendMessageA(inst->hwnd, WM_GETTEXT, ARRAY_SIZE(buffer), (LPARAM)buffer); + ok(strcmp(buffer, last_text) == 0, "Expected %s, got %s\n", wine_dbgstr_a(text_foo), wine_dbgstr_a(buffer)); + + hr = perform_editor_undo_state_action(inst, action, &count); + ok(SUCCEEDED(hr), "failed to transition\n"); + if (FAILED(hr)) return hr; + to_state = undo_control_state_transitions[from_state][action]; + if (to_state_ptr) *to_state_ptr = to_state; + if (to_state == undoStateDisabled) undo_count = redo_count = 0; + ok_msg_result(inst->hwnd, EM_CANUNDO, 0, 0, undo_count > 0); + ok_msg_result(inst->hwnd, EM_CANREDO, 0, 0, redo_count > 0); + + if (inst->test_flags & undoTestDoFirstUndo) + { + result = perform_undo(inst); + if (undo_count > 0) inst->undo_status = TRUE; + ok((to_state == undoStateActive && inst->undo_status) == result, "state %d->%d: got %d\n", from_state, to_state, result); + if (result && undo_count > 0) undo_count--, redo_count++, last_text = ""; + ok_msg_result(inst->hwnd, EM_CANUNDO, 0, 0, undo_count > 0); + ok_msg_result(inst->hwnd, EM_CANREDO, 0, 0, redo_count > 0); + SendMessageA(inst->hwnd, WM_GETTEXT, ARRAY_SIZE(buffer), (LPARAM)buffer); + ok(strcmp(buffer, last_text) == 0, "Expected %s, got %s\n", wine_dbgstr_a(last_text), wine_dbgstr_a(buffer)); + } + + if (inst->test_flags & undoTestDoFirstRedo) + { + result = perform_redo(inst); + if (redo_count > 0) inst->redo_status = TRUE; + ok((to_state == undoStateActive && inst->redo_status) == result, "state %d->%d: got %d\n", from_state, to_state, result); + if (result && redo_count > 0) undo_count++, redo_count--, last_text = text_foo; + ok_msg_result(inst->hwnd, EM_CANUNDO, 0, 0, undo_count > 0); + ok_msg_result(inst->hwnd, EM_CANREDO, 0, 0, redo_count > 0); + SendMessageA(inst->hwnd, WM_GETTEXT, ARRAY_SIZE(buffer), (LPARAM)buffer); + ok(strcmp(buffer, last_text) == 0, "Expected %s, got %s\n", wine_dbgstr_a(last_text), wine_dbgstr_a(buffer)); + } + + SendMessageA(inst->hwnd, EM_SETSEL, 0, -1); + SendMessageA(inst->hwnd, EM_REPLACESEL, TRUE, (LPARAM)(last_text2 = text_bar)); + if (to_state == undoStateActive) undo_count++, redo_count = 0; + ok_msg_result(inst->hwnd, EM_CANUNDO, 0, 0, undo_count > 0); + ok_msg_result(inst->hwnd, EM_CANREDO, 0, 0, redo_count > 0); + SendMessageA(inst->hwnd, WM_GETTEXT, ARRAY_SIZE(buffer), (LPARAM)buffer); + ok(strcmp(buffer, last_text2) == 0, "Expected %s, got %s\n", wine_dbgstr_a(last_text2), wine_dbgstr_a(buffer)); + + result = perform_undo(inst); + if (undo_count > 0) inst->undo_status = TRUE; + ok((to_state == undoStateActive) == result, "state %d: got %d\n", to_state, result); + if (result && undo_count > 0) undo_count--, redo_count++, last_text2 = last_text; + ok_msg_result(inst->hwnd, EM_CANUNDO, 0, 0, undo_count > 0); + ok_msg_result(inst->hwnd, EM_CANREDO, 0, 0, redo_count > 0); + SendMessageA(inst->hwnd, WM_GETTEXT, ARRAY_SIZE(buffer), (LPARAM)buffer); + ok(strcmp(buffer, last_text2) == 0, "Expected %s, got %s\n", wine_dbgstr_a(last_text2), wine_dbgstr_a(buffer)); + + result = perform_redo(inst); + if (redo_count > 0) inst->redo_status = TRUE; + ok((to_state == undoStateActive) == result, "state %d: got %d\n", to_state, result); + if (result && redo_count > 0) undo_count++, redo_count--, last_text2 = text_bar; + ok_msg_result(inst->hwnd, EM_CANUNDO, 0, 0, undo_count > 0); + ok_msg_result(inst->hwnd, EM_CANREDO, 0, 0, redo_count > 0); + SendMessageA(inst->hwnd, WM_GETTEXT, ARRAY_SIZE(buffer), (LPARAM)buffer); + ok(strcmp(buffer, last_text2) == 0, "Expected %s, got %s\n", wine_dbgstr_a(last_text2), wine_dbgstr_a(buffer)); + + return S_OK; +} + +static void test_undo_control(void) +{ + enum editorUndoState state0, state1, state2; + enum editorUndoStateAction action0, action1; + IRichEditOle *reole = NULL; + ITextSelection *selection; + struct undo_test inst = { NULL }; + HRESULT hr; + + create_interfaces(&inst.hwnd, &reole, &inst.doc, &selection); + inst.undo_status = TRUE; + inst.redo_status = TRUE; + + inst.undo_limit = SendMessageA(inst.hwnd, EM_SETUNDOLIMIT, 100, 0); + ok(inst.undo_limit >= 1, "Message EM_SETUNDOLIMIT returned %#Ix\n", inst.undo_limit); + + hr = set_editor_undo_state(&inst, undoStateActive); + if (SUCCEEDED(hr)) + { + for (inst.test_flags = 0; inst.test_flags < undoTestMaxFlag; inst.test_flags++) + { + for (state0 = firstUndoState; state0 < numUndoStates; state0++) + { + for (action0 = firstUndoAction; action0 < numUndoActions; action0++) + { + for (action1 = firstUndoAction; action1 < numUndoActions; action1++) + { + winetest_push_context("%x:%d:%d+>?:%d", inst.test_flags, state0, action0, action1); + hr = set_editor_undo_state(&inst, state0); + winetest_pop_context(); + + if (FAILED(hr)) continue; + + winetest_push_context("%x:%d:%d+>?:%d", inst.test_flags, state0, action0, action1); + hr = subtest_undo_control(&inst, state0, action0, &state1); + winetest_pop_context(); + + if (FAILED(hr)) continue; + + winetest_push_context("%x:%d:%d>%d:%d+", inst.test_flags, state0, action0, state1, action1); + subtest_undo_control(&inst, state1, action1, &state2); + winetest_pop_context(); + } + } + } + } + } + + release_interfaces(&inst.hwnd, &reole, &inst.doc, &selection); +} + START_TEST(richole) { /* Must explicitly LoadLibrary(). The test has no references to functions in @@ -4996,4 +5461,6 @@ START_TEST(richole) test_MoveEnd_story(); test_character_movement(); test_clipboard(); + test_undo(); + test_undo_control(); } -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/320

June 27, 2022

[PATCH v2 0/1] MR320: riched20/tests: Test for ITextDocument::Undo and ITextDocument::Redo.

by Jinoh Kang (＠iamahuman)

Signed-off-by: Jinoh Kang <jinoh.kang.kr(a)gmail.com> -- v2: riched20/tests: Test for ITextDocument::Undo and ITextDocument::Redo. https://gitlab.winehq.org/wine/wine/-/merge_requests/320

June 27, 2022

Re: [PATCH 0/5] MR322: winex11.drv: Preparation for nulldrv display modes.

by Zhiyi Zhang (＠zhiyi)

> Though it seems to me that calling NtUserGetPrimaryMonitorRect returns the current monitor size, which is initialized to whatever is configured in winecfg, but may change if the mode is changed? Shouldn't we always report a mode with the winecfg resolution instead? Right, querying from the registry seems more robust. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/322#note_2775

June 27, 2022

Re: [PATCH v3 0/4] MR310: mf: Fix several reference leaks.

by Nikolay Sivov (＠nsivov)

Tests commit is a much larger change than subject suggests, could you limit it to some missing release/shutdown calls? Also some or maybe all of ShutdownObject are not doing anything. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/310#note_2774

June 27, 2022

[PATCH 2/2] winealsa.drv: Set device path for all devices.

by Arkadiusz Hiler

From: Arkadiusz Hiler <ahiler(a)codeweavers.com> Signed-off-by: Arkadiusz Hiler <ahiler(a)codeweavers.com> --- dlls/winealsa.drv/alsa.c | 77 +++++++++++++++++++--------------------- 1 file changed, 36 insertions(+), 41 deletions(-) diff --git a/dlls/winealsa.drv/alsa.c b/dlls/winealsa.drv/alsa.c index b91606603a2..d8daca7dff7 100644 --- a/dlls/winealsa.drv/alsa.c +++ b/dlls/winealsa.drv/alsa.c @@ -2318,21 +2318,21 @@ static NTSTATUS get_prop_value(void *args) if(IsEqualPropertyKey(*prop, devicepath_key)) { + enum AudioDeviceConnectionType connection = AudioDeviceConnectionType_Unknown; + USHORT vendor_id = 0, product_id = 0; char uevent[MAX_PATH]; - FILE *fuevent; + FILE *fuevent = NULL; int card, device; + UINT serial_number; + char buf[128]; + int len; - /* only implemented for identifiable devices, i.e. not "default" */ - if(!sscanf(name, "plughw:%u,%u", &card, &device)){ - params->result = E_NOTIMPL; - return STATUS_SUCCESS; + if(sscanf(name, "plughw:%u,%u", &card, &device)){ + sprintf(uevent, "/sys/class/sound/card%u/device/uevent", card); + fuevent = fopen(uevent, "r"); } - sprintf(uevent, "/sys/class/sound/card%u/device/uevent", card); - fuevent = fopen(uevent, "r"); if(fuevent){ - enum AudioDeviceConnectionType connection = AudioDeviceConnectionType_Unknown; - USHORT vendor_id = 0, product_id = 0; char line[256]; while (fgets(line, sizeof(line), fuevent)) { @@ -2365,41 +2365,36 @@ static NTSTATUS get_prop_value(void *args) } fclose(fuevent); + } - if(connection == AudioDeviceConnectionType_USB || connection == AudioDeviceConnectionType_PCI){ - UINT serial_number; - char buf[128]; - int len; - - /* As hardly any audio devices have serial numbers, Windows instead - appears to use a persistent random number. We emulate this here - by instead using the last 8 hex digits of the GUID. */ - serial_number = (guid->Data4[4] << 24) | (guid->Data4[5] << 16) | (guid->Data4[6] << 8) | guid->Data4[7]; - - if(connection == AudioDeviceConnectionType_USB) - sprintf(buf, "{1}.USB\\VID_%04X&PID_%04X\\%u&%08X", - vendor_id, product_id, device, serial_number); - else /* AudioDeviceConnectionType_PCI */ - sprintf(buf, "{1}.HDAUDIO\\FUNC_01&VEN_%04X&DEV_%04X\\%u&%08X", - vendor_id, product_id, device, serial_number); - - len = strlen(buf) + 1; - if(*params->buffer_size < len * sizeof(WCHAR)){ - params->result = E_NOT_SUFFICIENT_BUFFER; - *params->buffer_size = len * sizeof(WCHAR); - return STATUS_SUCCESS; - } - out->vt = VT_LPWSTR; - out->pwszVal = params->buffer; - ntdll_umbstowcs(buf, len, out->pwszVal, len); - params->result = S_OK; - return STATUS_SUCCESS; - } - }else{ - WARN("Could not open %s for reading\n", uevent); - params->result = E_NOTIMPL; + /* As hardly any audio devices have serial numbers, Windows instead + appears to use a persistent random number. We emulate this here + by instead using the last 8 hex digits of the GUID. */ + serial_number = (guid->Data4[4] << 24) | (guid->Data4[5] << 16) | (guid->Data4[6] << 8) | guid->Data4[7]; + + if(connection == AudioDeviceConnectionType_USB) + sprintf(buf, "{1}.USB\\VID_%04X&PID_%04X\\%u&%08X", + vendor_id, product_id, device, serial_number); + else if (connection == AudioDeviceConnectionType_PCI) + sprintf(buf, "{1}.HDAUDIO\\FUNC_01&VEN_%04X&DEV_%04X\\%u&%08X", + vendor_id, product_id, device, serial_number); + else + { + ERR("name: %s\n", name); + sprintf(buf, "{1}.ROOT\\MEDIA\\%04u", serial_number & 0x1FF); + } + + len = strlen(buf) + 1; + if(*params->buffer_size < len * sizeof(WCHAR)){ + params->result = E_NOT_SUFFICIENT_BUFFER; + *params->buffer_size = len * sizeof(WCHAR); return STATUS_SUCCESS; } + out->vt = VT_LPWSTR; + out->pwszVal = params->buffer; + ntdll_umbstowcs(buf, len, out->pwszVal, len); + params->result = S_OK; + return STATUS_SUCCESS; } else if (flow != eCapture && IsEqualPropertyKey(*prop, PKEY_AudioEndpoint_PhysicalSpeakers)) { unsigned int num_speakers, card, device; char hwname[255]; -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/325

June 27, 2022