Update Vietnamese translation

Merge branch 'dboles/PopoverMenu-png' into 'main'

Fix broken image menu.png in Gtk.PopoverMenu intro

See merge request GNOME/gtk!6187

Merge branch 'dboles/for-main' into 'main'

tools: Replace references to GTK+ with GTK no plus

See merge request GNOME/gtk!6199

Update Vietnamese translation

(cherry picked from commit e944cd89166aa35c290b508057d2269859b27591)

Merge branch 'wip/otte/vulkan-for-main' into 'main'

gsk: Add gskrectprivate.h

See merge request GNOME/gtk!6201

gdk: Add function to query alpha format for depth

It's meant to be used in renderers.

gdk: Make A8 and A16 formats premultiplied

The relevant question here is about details, because we have to choose
if we declare alpha-only formats as having their (nonexistant) color
channels premultiplied or not, so that the code paths using them can do
the right thing.

Because we are premultiplied by default, it makes sense to treat alpha
like that, because then the alpha-only code doesn't need to do
workarounds for straight alpha.

Where this is relevant of course is when expanding the alpha channel
into color channels, where we want to end up with white.
So make sure we do color = alpha there instead of color = 1 like we did
before.

memoryformat: Copy idea from tiff code

The static assertion makes sure that newer formats get added.

gdk: Add A16_FLOAT and A32_FLOAT formats

We need them for mask-only textures.

For tiffs, we convert the formats to RGBA (the idea that tiff can save
everything needs to be buried I guess) as tiffs can't do alpha-only.

vulkan: Remove unused struct

gsk: Add gskrectprivate.h

Add a bunch of inline functions for graphene_rectangle_t.

We use those quite extensively in tight loops so making them as fast as
possible via inlining has massive benefits.

The current render-heavy benchmark I am playing (th paris-30k in node-editor)
went from 49fps to 85fps on my AMD.

vulkan: Add new error code

Update Greek translation

(cherry picked from commit 9d633773b0952ecd7cf53a54a71feb4c7706f6d4)

tools: Replace references to GTK+ with GTK no plus

Merge branch 'render-tool' into 'main'

Add gtk4-render-tool

See merge request GNOME/gtk!6197

Add a gtk4-rendernode-tool

This is meant to work with serialized render nodes.

Merge branch 'dboles/for-main' into 'main'

ShortcutController: Add links to docs, fix heading

See merge request GNOME/gtk!6198

ShortcutController: Add links to docs, fix heading

to be "as GtkBuildable", not "as a GtkBuildable", as no other file uses
the latter.

Merge branch 'wip/kabus/calendar-select-signal' into 'main'

gtk/calendar: Avoid emision of day-selected signal from nav buttons

Closes #5769

See merge request GNOME/gtk!6196

gtk/calendar: Avoid emision of day-selected signal from nav buttons

gdk: Drop unnecessary conditionals

We require GLib 2.76 now.

tools: Use #pragma once

We are trying to be consistent about this.

tools: Drop unnecessary conditionals

We require GLib 2.76 now.

Merge branch 'gtk-fix-issue-4990' into 'main'

Add check for large compose files

Closes #4990

See merge request GNOME/gtk!6195

Make the new compose table test work

This just copies what we do already for other
tests that check parser failures.

Merge branch 'wip/otte/vulkan-for-main' into 'main'

vulkan: Various smallish things

See merge request GNOME/gtk!6193

vulkan: Be more careful with supported images

Now that we can upload all these fancy formats, we need to make sure
that we actually can.

memoryformat: fast-path copies of the same format

Basically, memcpy() asap if possible.

This happens a lot in Vulkan, where we gdk_memory_conert() image
data from memory textures straight into the VulkanBuffer.

And usually we support the format.

vulkan: Add premultiply step to texture upload

When a GdkMemoryFormat is not supported natively and there's
postprocessing required, add a way to mark a VulkanImage as such via the
new postprocess flags.

Also allow texting such iamges only with new_for_upload() and detect
when that is the case and then run a postprocessing step that converts
that image to a suitable format.
This is done with a new "convert" shader/op.

This now supports all formats natively, no conversions happen on the CPU
anymore (unless the GPU is old).

vulkan: Change fallback formats

Always fall back to a format that isn't swizzled.

That way it can be used as a target format for rendering.

vulkan: Split renderpass op into 2

Add an explicit begin() and an end() op. For now, this looks like
overkill, but it allows doing renderpasses with custom ops that are not
meant to render a rendernode.

Examples for this are pre/postprocessing passes or 2-pass blur.

vulkan: Don't store the renderpass

It's only used when parsing.

vulkan: Pass rectangles where no regions are used

The API was using regions because it always had. But all the code ever
did was get the extents of the region.

So simplify everything by using rectangles everywhere.

vulkan: Stop keeping the context around

These days, we can query it with gsk_vulkan_render_get_context().

Makes quite a few functions require one less argument.
And it also makes the GskVulkanRenderPass empty. Gotta figure out what
to do with it.

vulkan: Remove unused stuff fom renderpass

... and move it to the one place where it is used.

vulkan: Free storage buffer when disposing render object

This caused a lot of leaked memory on the GPU when rendering textures.
(Read: inside node-editor)

vulkan: Fix leaks with pipeline cache

In particular, we were leaking the actual cache and then created a new
one.

build: Move the glslc check into the top meson file

Put it with the other Vulkan checks, so it's easy to find.

vulkan: Remove the pre-compiled shaders

Instead, build-depnd on glslc to build them.

glslc is available in all important distros for a while:
  Fedora >= 28
  Ubuntu >= 23.04
  Debian >= 12
  Arch
  Opensuse >= 15.2
  msys2
are the ones I checked.

So we can depend on it and avoid having to deal with keeping spirv files
up-to-date in all commits.

It's also 700kB of data, and not updating it helps.

ci: Include glslc for Vulkan builds

Add test for large compose file

See #4990

Add check for large compose files

Fixes #4990

Merge branch 'dboles/theme-no-backdrop-list-view-text' into 'main'

theme: Don't dim text in backdropped list/listview

See merge request GNOME/gtk!6175

Merge branch 'wip/otte/vulkan-for-main' into 'main'

vulkan: Make RenderOps into proper structs

See merge request GNOME/gtk!6188

vulkan: Rebuild the shaders

Just to be sure I didn't forget rebuilding some shader at some point.

vulkan: Redo barriers

We now store all the relevant state of the image inside the VulkanImage
struct, so we can delay barriers for as long as possible.

Whenever we want to use an image, we call the new
gsk_vulkan_image_transition() and it will add a barrier to the desired
state if one is necessary.

vulkan: Track the current pipeline stage of images

This way, we can in theory properly transition images because we know
which stage to transition from.

IN practice this is happening in future commits.

vulkan: Handle images in the ShaderOp

This looks more convoluted in this commit, but future commits will
hopefully make up for it.

vulkan: Make clip type an enum

and add gsk_vulkan_shader_op_alloc() that sets it properly.

vulkan: Introduce GskVulkanShaderOp

It's the new base class for shaders now.

We're doing deep inheritance now, woohoo!

Also, port all the shader ops to it.

vulkan: Remove GskVulkanUploader

... and all the remaining functions still using it.

It's all unused and has been replaced by upload and download ops.

With this change, all GPU operations now go via GskVulkanOp.command()
and no more side channels exist.

vulkan: Add GskVulkanDownloadOp

This op queues a download of an image. The image will only be available
once the commands finished executing, so it requires waiting for the
render to finish, which makes the API a bit awkward.

Included is also a download_png_op() useful for debugging.

vulkan: Properly update image layouts

The render pass ops were not updating the image's layout to the final
layout when a render pass ends.

Fix that.

Also make the layouts explicit arguments to the render pass op.

vulkan: Simplify render API

Merge reset() and draw() into a single render() function.

Also clean up some naming on the way.

vulkan: Remove the VulkanOp.upload() vfunc

It's not used anymore.

vulkan: Add an UploadGlyphOp

Now all the uploads have their own op.

vulkan: Split out a function

Split out the function that uploads using a buffer, so that it can be
used with an area to only update parts of the image.

That feature is not used yet, but will be in future commits.

vulkan: Remove unused functions

vulkan: Merge the two upload ops

Now they both use the same upload code.

vulkan: Merge te 2 upload ops

They are about to share a ton of code, sothey should be in the same
source file.

This commit just does the copying, no functional changes.

vulkan: Fold functions into only caller

Now that the VulkanOp does begin/end of render passes, there's no need
to have a renderpass function for it anymore.

tests: Reduce number of random fonts

We were clowing through all the Pango caches for no benefit.

It made the test generation stuck in fontconfig loops instead of
quickly generating tests.

So don't do that and limit the different fonts to some reasonable list
of options.

vulkan: Don't merge too many drawing commands

If a command takes too long to execute, Vulkan drivers will think they
are inflooping and abort what they were doing.

For the simple color shader with smallish nodes, this happens around
10M instances, as tested with the output of
  ./tests/rendernode-create-tests 10000000 colors.node

So just limit it to way lower, so that we barely never hit it, ut still
pick a big number so this optimization stays noticable.

vulkan: Simplify

The renderpassop always has a matching end op, so there is no need to
check for the end of operations and emit one manually.

vulkan: Merge function into only caller

The renderpass reshuffling means we can move a bunch of functions now.

This is one of them.

vulkan: Don't try that hard to use clear

For small regions, the optimization doesn't matter that much, so we
don't need to do lots of work on the CPU.

In particular, this should catch icons and their backgrounds (32x32),
but I was generous in selecting the number.

Gets my discrete AMD on widget-factory back to the 1900fps it had before
this optimization while making the driver clock the GPU's shader at
1.7GHz instead of the 2.1GHz it used before.

vulkan: Try really hard to use clear

Using clear avoids the shader engine (see last commit), so if we can get
pixels out of it, we should.

So we detect the overlap with the rounded corners of the clip region and
emit shaders for those, but then use Clear() for the rest.

With this in place, widget-factory on my integrated Intel TigerLake gets
a 60% performance boost.

vulkan: Add a clear op

The op emits a vkCmdClearAttachments() with a given color. That can be
used with color nodes that are pixel-aligned and opaque to significantly
speed up rendering when the window background is a solid color.

However, currently this fails a bit outside of fullscreen when rounded
clip rectangles are in use to draw rounded corners.

vulkan: Adapt a function

I want to use it for more operations when we can break those down to
operations on the pixels directly, and this function is what's needed
for that.

vulkan: Implement direct upload for the cairo op

vulkan: Upload cairo images "directly"

Instead of using the upload vfunc and going via the code in
GskVulkanImage, copy/paste the relevant code into the command() vfunc.

This is meant to achieve multiple things:
1. Get rid of GskVulkanUploader and its own command buffer and general
   non-integration with operations.
2. Get rid of GskVulkanOp:upload()
3. Get the upload/download code machinery for GskVulkanImage and put it
   with the actual operations.

The current code can't do direct upload/download, that will follow in a
future commit.

vulkan: Split out a function

This is refactoring for future changes.

vulkan: Emit a renderpass op

... instead of doing the equivalent things manually by creating a
RenderPass and calling the relevant functions.

Now all renderpass operations are indeed stored in ops.

Also reshuffle the command emission code, because we no longer need to
emit the ops for the base renderpass.

As a result we only submit a single command buffer containing all the
render passes instead of once per render pass.
We also bind vertex buffers and descriptor sets only once now at the
start instead of once per renderpass.

vulkan: Sort the ops

Use the OpClass.stage to order operations:

1. Put upload ops first
   This way we can ensure they are executed first.
2. Move subpasses for offscreens in front of the pass using them.

vulkan: Store a pointer to the first op

This is not yet useful, but will be soon.

vulkan: Indent verbose prints again

This feature was lost when refactoring, restore it.

vulkan: Rename offscreenp to renderpassop

They should be used for all renderpasses, not just offscreens.

vulkan: Move the render ops to the Render

This is a massive refactoring because it collects all the renderops
of all renderpasses into one long array in the Render object.

Lots of code in there is still flaky and needs cleanup. That will
follow in further commits.

Other than that it does work fine though.

vulkan: Batch together multiple draw calls

If multiple instances of the same op appear in order, we can emit one
vkCmdDraw() for all of them together.

So do that.

vulkan: Unify some functions

All the ops that just execute a shader do pretty much the same stuff, so
put it all in a single function that they all call.

It's basically faking a base class for them.

vulkan: Make Op->command() return the next op

This way, ops can batch themselves.

They don't dothat yet, but you know where this is going...

vulkan: Add a Stage enum

It's declaring at which stage this command should run. So far nothing is
using it, but that will follow in future commits.

vulkan: Bind descriptor sets early

Simplfies the code and doesn't change anything.

vulkan: Remove unused arguments from Op vfuncs

Makes code a lot simpler.

vulkan: Cache VkRenderPasses in render object

Instead of recreating the same renderpass object in every frame and for
every offscreen, just reuse it.

Technically, we can save this per-renderer or even per-display (it
should really be cached by VkDevice), but we have no infrastructure for
that.

vulkan: Rename function

The function name gsk_vulkan_render_get_pipeline() had been used for
GskVulkanPipeline. Since those are gone now, we can use that name for
VkPipelines.

vulkan: Cache framebuffer in image

Instead of recreating them every frame for every render pass, reuse the
same framebuffer.

vulkan: Put the vertex buffer into the render object

Renderpasses get recreated every frame, but we keep render objects
around. So if we keep the vertex buffer in the render object, we can
also keep it around and just reuse it.

Also, we only need one buffer for all the render passes, which is
another bonus.

The initial buffer size is chosen at 128kB. Maximized Nautilus,
gnome-text-editor with an open file and widget-factory take ~100kB when
doing a full redraw. Other apps are between 30-50kB usually.

So I chose a value that is not too big, but catches ~90% of cases.

vulkan: Add an offscreen end op

This is basically a fancy no-op for now, but reordering of ops will need
it to indicate end of offscreen commands.

vulkan: Don't intern strings

Interning strings is slow, especially if we can instead do direct
pointer compares.

Also refactor the pipeline lookup code a bit to make use of the
refactored code.

vulkan: Add VulkanOp->next

Set it after creating all the ops and then use it for iterating.

Note that we cannot set it while creating the ops because the array may
be realloc()ed into a different memory region which would invalidate all
the pointers.

It currently has no use, but that will come later.

Also put the typedefs into headers in gsk/vulkan, they have nthing to do
outside that directory.

vulkan: Remove all the semaphores

They aren't necessary with just one queue.

vulkan: Remove unused stuff from render object

Neither cleanup images nor multiple renderpasses are used anymore since
both of those are now handled inside the render ops.

vulkan: Pass the node when setting up

Remove the function to add a node from both the GskVulkanRender and the
GskVulkanRenderPass.

That means they are both now meant to draw exactly one node.

vulkan: Add infrastructure for printing ops

... and add a GSK_DEBUG=verbose setting making use of it.

vulkan: Repurpose mask shader

Use if for mask nodes to do the generic source image + mask image
operation with the 4 available mask modes.

vulkan: Remove op.get_pipeline()

It's unused now that GskVulkanPipeline is gone.

vulkan: Remove GskVulkanPipeline

Pipelines are handled differently now.

vulkan: Add gskvulkanprivate.h

It's the new place for all the common stuff.

Because the old place is about to go away.

vulkan: Turn push constants into an op

This removes the last remaining original op from the gskvulkanrenderpass.c,
so that file got some cleanup, too.