Problem with multiple shapes from X11, Cairo, SDL2-GFX or other rectangle-like functions

[DeafMan1983]

Hello everyone,

I would like to appreciate about multiple shapes from own functions by P/Invoke but I am really surprised because dotnet can shows after publish native aot generated executable and it shows real multiple rectangles from libX11->XDrawRectangles() and it seems like "It works fine".
Example I have made X11 via P/Invoke

But I press any key for destroying window and display and it happens it said Segmentation fault (core dumped)

That is why - I expected great c#-writer called "arbiter"
He tells about how do somebody marshal with native IntPtr to Reectangle[]?

I get successful P/Invoke and marshaling with Rectangle arrays and passing XDrawRectangles() from libX11.so:
int XDrawRectangles(Display *display, Drawable d, GC gc, XRectangle rectangles[], int nrectangles);

I tried after published with native aot or without:
But it said.

Thread 1 "X11Test" received signal SIGSEGV, Segmentation fault.
0x00007fff742e0d7f in XDrawRectangles () from /lib/x86_64-linux-gnu/libX11.so

I really don't know how do I fix without Segmentation Fault.

I have written for example:
Method 1:
via P/Invoke:

[DllImport(libX11, EntryPoint="XDrawRectangles")]
public static extern int XDrawRectangles(Display *display, Drawable drawable, GC gc, XRectnagle[] rectangles, int number_rects);

and result shows only Segmentation Fault.

Method 2:
With pointer *:

[DllImport(libX11, EntryPoint="XDrawRectangles")]
public static extern int XDrawRectangles(Display *display, Drawable drawable, GC gc, XRectnagle* rectangles, int number_rects);

and result shows again Segmentation Fault.

Method 3:
Advanced with marshaling mode:

[DllImport(libX11, EntryPoint="XDrawRectangles")]
private static extern int __XDrawRectangles(Display *display, Drawable drawable, GC gc, IntPtr rect_ptr, int number_rects);
public static int XDrawRectangles(Display *display, Drawable drawable, GC gc, XRectnagle[] rectangles, int number_rects)
{
    int rect_size = Marshal.SizeOf<XRectnagle>();
    nint rect_ptr = Marshal.AllocHGlobal(rect_size * number_rects);
    Int64 longPtr = rect_ptr.ToInt64();
    for (int idx = 0; idx < rectangles.Length; idx++)
    {
        IntPtr ptr = new IntPtr(longPtr);
        Marshal.StructureToPtr<XRectnagle>(rectangles[idx], ptr, false);
        longPtr += Marshal.SizeOf<XRectnagle>();
    }

    if (number_rects < 0)
    {
        throw new IndexOutOfRangeException();
    }

    return __XDrawRectangles(display, drawable, gc, rect_ptr, number_rects);
}

and result shows again Segmentation Fault.

And last method like same to Method 3:
It seems really crazy. How do I know about X11's XDrawRectangles() without problems?

For dotnet run -c Release or dotnet run can't show up because Window blends until no warning if it doesn't tell about Segmentation Fault. It looks like crashed.

And I have made with hard-coded OOP as "X11CPP-Wrapper" for C#, Java and other...
Example:

int x11cpp_draw_rectangles(X11Display *display, X11Window *window, X11GC *gc, XRectangle rects[], int number_rects)
{
    return gc->DrawRectangles(display, window, rects, number_rects);
}

Result It works fine like charm.

terminal shows without any segment faults.

Why does it expect about P/Invoke and Wrapper?
Like SFML framework made Wrapper and it works fine like charm. But why does it not work for 1:1 equipment example C# <-> C++ with Wrapper, Java <-> C++ with JNA and Python <-> C++ with ctypes and more...

Please tell me why does P/Invoke not work for 1:1 for Non-Windows frameworks like you saw Gtk2 has Wrapper like GtkSharp2 with 3 or 4 built shared libraries - found from Mono's Runtime with GtkSharp 2's libraries

I know far why we do not care about Wrappers?
But I see like other need to use Wrappers if it works for 1:1 equipment.

Thanks for understanding and supporting!

[tannergooding]

Can you provide the signatures of your: Drawable, GC, and XRectangle types?

Also just to confirm, you're only using this from a Unix operating system and not from something like CYGWIN or MINGW on Windows?

It is likely that your interop signature is slightly incorrect for the direct binding scenario so understanding fully what you've defined will help.

There are also a lot of subtleties to using X11 correctly across a broad range of distributions and some more advanced concepts are not always well-specified. http://github.com/terrafx/terrafx.interop.xlib is a library I own which provides 1-to-1 blittable bindings of Xlib and https://github.com/terrafx/terrafx/tree/experimental/vulkan/sources/UI/Xlib/UI shows an example of using this as part of a higher level abstraction. You'll note there is a quite a bit of state management around the Xlib ATOMS, particularly for the backing "window manager" (_NET_WM_*), tracking of what is actually supported vs not by the underlying implementation, handling of xlib events (which involves reverse P/Invoke in addition to regular P/Invoke), and handling of xlib errors (which likewise require setting up reverse p/invoke hooks).

[DeafMan1983]

Hello @tannergooding are you trying to use multiple rectangles in XDrawRectangles(). Are you sure about 1:1 blittable of your made Xlib. Ok I will test your library.

What is the hell? If I use git clone --recursive https://github.com/terrafx/terrafx/ then cd terrafx and and I checked ls then where are sh files and nothing. Please stop manipulating me with Windows-liked types.
I have proof video I will show you why does your repository happen if I am using Linux, Ubuntu 22.04. It is not Windows just Linux/Unix OS.

Wait for uploading....

[DeafMan1983]

Okay thanks And I have updated comment...

[tannergooding]

What is the hell? If I use git clone --recursive https://github.com/terrafx/terrafx/ then cd terrafx and and I checked ls then where are sh files and nothing. Please stop manipulating me with Windows-liked types.

I linked to a specific branch: experimental/vulkan. Linux support is still experimental (and not in main) because there are a great number of scenarios that need to be tested across a wide range of Linux distributions. Not all Linux window managers are fully compliant with the various Xlib specs or extensions and this can be seen if you browse the source of existing larger windowing libraries including SDL, GTK, QT, etc. All of them have various comments and workarounds for various quirks that systems may have in their implementations.

It is also just an example of how one might use the direct Xlib bindings. http://github.com/terrafx/terrafx.interop.xlib are the direct bindings and would be what you'd want to test your own implementation.

[DeafMan1983]

It is also just an example of how one might use the direct Xlib bindings. http://github.com/terrafx/terrafx.interop.xlib are the direct bindings and would be what you'd want to test your own implementation.

Yeah I have downloaded with dotnet add package ....
But I don't have dotnet 5.x because dotnet-install script tells me dotnet 5.x is out of support.

How do I want test with finished nuget package for Dotnet 6.0 and 7.0

Thanks I am sorry for hestitating with msys2 and cygwin because I am really sensitive for Windows Spreading. My bad memory of Windows cause since I want return but hackers are very intelligent and they make my life bad and catch my whole google accounts. That is why I get mad. But my google accounts are safe now. That is why my bad memory of past. I am sorry for that. Please believe me! I want get nuget package thanks!

// UPDATE:
I have added into my project with csproj from Terra>fx.Interop.Xlib then it said error red line because i can't cast with Window.

I really want know how did you get successful with casting Window of Drawable?

Thank you for helping!
And I catch Value of Window should cast to Drawable :D

Thank you so much!

But how do I expect about Java <-> C When SDL2 can't close 4. line and 1. lien as corner.
For C# it works fine like same 1 to 1 blittable.

[tannergooding]

TerraFX.Interop.Xlib supports .NET 6: https://www.nuget.org/packages/TerraFX.Interop.Xlib/6.3.0-beta3. I've not pushed up the latest version which adds .NET 7 support and marks it as "stable" yet but could do so later this evening. For the experimental/vulkan branch of TerraFX proper; I can likewise update it to .NET 6/7 later tonight.

In the interim, sharing the Drawable, GC, and XRectangle types you defined in your failing sample would potentially help us unblock your own code.

[DeafMan1983]

Hey my dear,

I would like to add advanced Conversion Functions for sbyte * and string :D

public static int StringOfSize(string str_value)
{
    if (str_value == null)
        {
            return 0;
        }
        return (str_value.Length * 4) + 1;
}

public static sbyte *StringFromCharPtr(string str_value, sbyte *buf_value, int size_value)
{
    if (str_value == null)
        {
            return (sbyte*)0;
        }
        fixed (char* strPtr = str_value)
        {
            Encoding.UTF8.GetBytes(strPtr, str_value.Length + 1, (byte *)buf_value, size_value);
        }
        return buf_value;
}

public static sbyte *StringFromHeap(string str_value)
{
    if (str_value == null)
    {
        return (sbyte*)0;
    }

    int strOfSize = StringOfSize(str_value);
    sbyte* buf_value = (sbyte*)Marshal.AllocHGlobal(strOfSize);
    fixed (char* strPtr = str_value)
    {
        Encoding.UTF8.GetBytes(strPtr, str_value.Length + 1, (byte *)buf_value, strOfSize);
    }
    return buf_value;
}

private static string CharPtrToString(sbyte *charptr)
{
    if (charptr == null)
    {
        return string.Empty;
    }

    sbyte *buf_value = charptr;
    while (*buf_value != 0)
    {
        ptr++;
    }

    return Encoding.UTF8.GetString((byte *)charptr, (int)(buf_value - (sbyte *)charptr));
}

I hope you add important conversion functions for TerraFX.Interop.Xlib; if they are lazy to type how do they understand sbyte * and string

Have nice day!