iWidget | A open-source iOS Widget APP by WidgetKit for iOS14 | Widget library

This is very close to working. The problem is that you have made your IWidget derivative interfaces empty. Since the SerializationBinder is binding the $type codes in the JSON to interfaces instead of concrete types, the contract resolver is going to look at the properties on those interfaces to determine what can be deserialized. (The contract resolver's main responsibility is to map properties in the JSON to their respective properties in the class structure. It assigns a "contract" to each type, which governs how that type is handled during de/serialization: how it is created, whether to apply a JsonConverter to it, and so forth.)

IAssembly doesn't have a Parts list on it, so that's as far as the deserialization gets. Also, the Name property on IWidget does not have a setter, so the name of the root assembly object doesn't get populated either. The NRE is being thrown in the ToString() method in the demo code which is trying to dump out the null Parts list without an appropriate null check (that one's on me). Anyway, if you add the public properties from the concrete Widget types to their respective interfaces, then it works. So:

This answer will install the latest release of Ruby (at the time of writing), along with the latest compatible version of Tcl.

Note: after installing Ruby 2.7.0, $ gem install tk says "Tcl/Tk8.6 is not supported[;] it will not work correctly." So, instead we must limit our use of Tcl to version 8.5. We will do this by installing ActiveTcl version 8.5.

These steps are for Debian Stretch—so, for Fedora 31, YMMV. :)

Create some directories:

It's the end of the day, I thought I'd flesh out my comment. This is what I meant by a "pattern matching switch statement":

One possible solution would be to configure the items after the list is displayed. You need for this:

• new Version of vmCombobox (check out svn)

  Example:

  !/bin/sh \

  exec vmwish "$0" ${1+"$@"}

  package require Itcl package require vmWidgets package require vmTclTools toplevel .t frame .t.fr pack .t.fr

  global wms variable var set cb1 [vmCombobox .t.fr.li\ -textvariable ::wms(capabilitiesAddr)\ -selectioncommand getV\ -textfont {helvetica 10 bold}\ -labelfont {helvetica 10 bold}\ -values [list 1 2 3 33i 1000 7]\ -textvariable ::wms(var)\ -height 20\ -validate all\ -validate {valMass %P}\ -labeltext testcombobox\ ] pack $cb1

  $cb1 insert list end jojo set pd [$cb1 getPopdown] $cb1 configure -postcallback [list configureLB $pd] proc configureLB {pd} { foreach i [$pd get 0 end] { # hier Items konfigurieren puts $i } $pd itemconfigure end -foreground red }

I solved it.

How I draw different kinds of shapes:

Below I wrote parser using Xml Linq that will work

If you don't need to have the EntitiesList to be a specific type you could just have the SubWidget be generic and set its type when you instantiate.

What CoMarshalInterface actually needs is IMarshal implementation (pointer) for the given interface, so that API could request the marshaling magic from it and, in particular, request IMarshal::GetUnmarshalClass in order to obtain information who is going to do the reverse magic afterwards:

This method is called indirectly, in a call to CoMarshalInterface, by whatever code in the server process is responsible for marshaling a pointer to an interface on an object. This marshaling code is usually a stub generated by COM for one of several interfaces that can marshal a pointer to an interface implemented on an entirely different object.

You don't have IMarshal implemented on your widget, so you are going to get it somewhere from.

As you started your question mentioning that you "want to marshal an interface to another thread" and the code comment says "Create our widget" there is a chance that you can utilize IMarhsal implementation of free threaded marshaler. The question does not provide information to tell whether it is possible and/or acceptable solution.

Back to the challenge of obtaining a marshaler, you are trying to work this around by utilizing a "standard" marshaler by "registering the interface":

why is the standard COM marshaler having so much problems

[...]

I of course can register my interface in the registry

Well, this is not how things actually work.

Interface registration is not just a registry key that "okay, this IID has its own key in the registry". The purpose of such registration is to point where to look for proxy/stub pair for this interface. Your manual creating of registry entries cannot help here if you don't have a proxy/stub DLL for the interface in question. If you had it, you would just regsvr32 it the usual way to create the registry keys.

So called standard marshaler, your next try, is not supposed to marshal any interface and your IWidget in particular. OLE supplies so called "PSOAInterface" marshaler, which is capable of supplying proxy/stub pairs for OLE Automation compatible interfaces. Just for them! The marshaler does not have so much problems, it actually has just one: your IWidget is unlikely to be compatible or you would not have the problem in first place.

If your IWidget was compatible, had an associated type library, where it was marked as [oleautomation], the type library registration process would have automatically created the registry keys referencing PSOAInterface and supplying ProxyStubClsid32. Then marshaling API would have picked PSOAInterface for your widget, it would have picked up the registered type library, load details of the interface, then provided standard proxy/stub pair for it and that's it. Standard marshaler works just within these contraints and not just for any interface pointed to.

That is, your options are:

• implement IMarshal on the widget server
• make IWidget OLE Automation compatible, with type library, so that type library registration process activates "standard marshaler" PSOAInterface for your interface
• build, if possible and applicable, proxy/stub implementation for your interface automatically generated by MIDL complier (you can check standard ATL DLL project, created from Visual Studio template on how it can be done - it creates additional project with "PS" suffix, for a supplementary proxy/stub DLL)
• implement separately IMarshal in a standalone DLL, and register it with the registry and your IWidget interface, so that marshaling API would pick it up when it attempts to marshal the interface pointer (I suppose it's the only option here if your IWidget is OLE incompatible and you have reasons to not alter the original implementation)
• use free threaded marshaler in the widget server if its restrictions are acceptable

Oh wait, hold on - there is another weird one. If you don't want or cannot afford, or you are reluctant to change the COM server (widget, that is) but you can modify client side code as you like, you can create a thin wrapper that implements two interfaces IWidget (all methods forward calls to real server) and IMarshal on client side, and pass its IWidget to the CoMarshalInterThreadInterfaceInStream API. This will force COM to use your marshaling without altering the original server. You are on your own, of course, to do the actual marshaling afterwards. It is unlikely that it matches your actual need, and it is just an abstract note to the discussion (which mostly consists of attempts to do impossible without details on interface itself and available options on modification of server implementation).

The short answer is that you can't abstract away your question like this. For example what makes a Widget and a ThisThing so simmilar that they can be listed together but a ThatThing can't be?

Just consider it like this