modern

i've founded solution: It is not possible to change the style on the fly, because QQC2 styling is based on QML type registration time file selection, but it is possible to:

unload all QML, destroy any existing QQmlEngine instance(s), call qmlClearTypeRegistrations(), call QQuickStyle::setStyle(), and then re-load the QML content so that QQC2 types are re-registered with the new style. This process should be clearly documented in QQuickStyle. Preferably, an example should be provided that uses QML Settings to retain the state of the UI, for example.

It is important to emphasize the warning in the qmlClearTypeRegistrations() docs:

Do not call this function while a QQmlEngine exists or behavior will be undefined. Any existing QQmlEngines must be deleted before calling this function. This function only affects the application global cache. Delete the QQmlEngine to clear all cached data relating to that engine.

You can concatenate the input from two text in onclick -

The UID of a user is a unique, constant identifier for that user. So if the same user logs in multiple times, they'll get the same UID.

It makes no sense to use the ID token as the identifier for the user in the database, as an ID token will change every hour.

You should continue to use the UID to identify the user, and only use the ID token when you need to verify the user's identity.

Oh they're trying very hard to destroy 3rd party cookies altogether. Not sure if yours are third party or not.

https://blog.chromium.org/2020/01/building-more-private-web-path-towards.html

"we plan to phase out support for third-party cookies in Chrome. Our intention is to do this within two years"

Already every other Chrome update destroys integrations between sites that depend on the samesite behavior you mention.

This checkin reverted behavior to a more tolerant samesite behavior because a previous samesite change broke so many sites. but it won't last for long. They will re-add it in the future.

https://chromium.googlesource.com/chromium/src/+/fdfe7482acbb6a4f5605103ce7d2956e2336e27e

template tag content is not ignored by browsers.

Think of a template as a content fragment that is being stored for subsequent use in the document. While the parser does process the contents of the element while loading the page, it does so only to ensure that those contents are valid; the element's contents are not rendered, however.

MDN

So the contents is parsed and validated. table elements have a specific list and order of permitted content. So when the template content is parsed the unsupported content is removed from the table.

You can see the same behavior if you use p tags within a table.

Is this code with modern C++11/14/17/21 is still the way we should compare float and doubles, or now it's ok just to write if (double1 == double2) And compiler will handle the epsilon issue for us?

Both approaches function the same in modern C++ as they did in early C++.

Both approaches are also flawed.

• Using == assumes that your code has accounted for any floating point rounding errors, and it's very rare/difficult for code to do that.

• Comparing against epsilon assumes that a reasonable amount of rounding error will be less than the constant epsilon, and that is very likely a wrong assumption!

  • If your numbers have magnitude greater than 2.0, your epsilon trick will be no different from direct comparison, and have the same flaws. Regardless of whether you use < or <=.
  • If your numbers have the same sign and a magnitude smaller than epsilon, your epsilon trick will say they are always equal, even if one is hundreds of times larger than the other. They would both be equal to zero, too.

A wise approach may be to avoid writing code that depends on whether floating point numbers are equal. Instead test if they are relatively close, by some factor.

The code below will test whether two numbers are within about 0.01% of each other. Regardless of their scale.

Try using no-spacebar option

https://github.com/sniperwolf/taggingJS#available-options

With code that triggers undefined behavior, the compiler can just about do anything - well, that's why it's undefined - asking for a safe definition of undefined code doesn't make any sense. Theoretical evaluations or observing the compiler translating similar code or assumptions on what "common practice" might be won't really give you an answer.

Evaluating what a compiler really has translated your UB code to would probably be your only safe bet. If you want to be really sure what happens in the corner cases, have a look at the generated (assembly or machine) code. Modern debuggers give you the toolset to catch those corner cases and tell you what actually happens (the generated machine code is, after all, very well defined). This will be much simpler and much safer than to speculate on what code the compiler might probably emit.

I found answer for my issue. The easiest way is to create Flow

1. Create recurrence - schedule your task
2. Use Get items - the items you'd like to move. In this action you should use advanced settings and choose filtering you wanna apply on your data (I've decieded that I need to copy every item that was created later than January 2021) - example. More about OData filters here.
3. Fill in next step (applied to all) - example
4. copy this Flow for every list you need to combine into one list

That's all actually. I created one more flow but this one is much easier. I hope it'll help