MyNotes | Sticky notes/post-it system tray app for linux

In your thunk, you are manually handling the error. There is no way that any other code after that could know that something went wrong.

You have three options here:

• do not try..catch in your createAsyncThunk call. The error will be cleaned up from non-standard fields and end up in action.error of the rejected action
• manually throw something. The error will be cleaned up from non-standard fields and end up in action.error of the rejected action
• manually return thunkApi.rejectWithValue(yourError). The error will not be cleaned up and land in action.payload of the rejected action.

What you are doing now (handling the error and returning nothing) is essentially equal to doing return undefined in your function - which will end up as a fulfilled action with undefined as payload.

I found a way to achive what i wished to do.

I saved my Text-widgets in a list. And then fetched the index from the tabs and got that index from my list. Eg:

Please review your code in your addNotes method.

Seems like you have inserted data twice:

It seems you have mixed up which version of react-bootstrap you are using. The Accordion component API changed between v1 (Bootstrap 4.6) and v2 (Bootstrap 5.1).

Here with react-bootstrap v1.6.4 your code works without issue.

V1 Accordion API

This version has the Accordion, Accordion.Toggle, and Accordion.Collapse components.

V2 Accordion API

The v2 version has a few more options with Accordion, Accordion.Item, Accordion.Header, Accordion.Body, Accordion.Button, and Accordion.Collapse.

I suggest sticking to v1.6.4 and keeping your existing code working. If you want, or need, to upgrade then it's a bit unclear what immediate component changes you'll need to have a similarly working UI/UX, though I suspect the new accordion components will replace some of the card components currently used.

You can use either named or default export of the notes though, just don't use the module.exports.

You are getting the following error:

Caused by: java.lang.NullPointerException: Attempt to invoke virtual method 'com.google.firebase.firestore.CollectionReference com.google.firebase.firestore.FirebaseFirestore.collection(java.lang.String)' on a null object reference

Because you are trying to use the firestore object before it is initialized. To solve this Exception, please move the following line of code:

I think it's because of the way you are declaring the variable, since you are declaring it as a direct function, you can try the following:

the problem is in your controller replace this

Error is in your Adapter Class. In the MyViewHolder class comment this line

The main problem is that you're not using layout managers.

Exactly as their name explain, they are responsible of managing the layout, meaning that they will position and resize their children (including widgets and other "nested" layouts) according to the available size and considering the restraints of those items: some widgets can have minimum, maximum or fixed dimensions, other can try to expand to the available space left, etc.

While there are situations for which using "fixed geometries" (meaning that the size and position of each item is not managed), it's generally good practice to use layouts instead. There are lots of reasons for which this is necessary, but the rule of thumb is that what you see on your screen is almost always never what any other user will see in theirs (different screen sizes and resolutions, different default font and font size, etc). This is almost the same reason for which every good modern website uses a "responsive design" that adapts the contents of the web pages to the screen of the user.

In your case, two things are mandatory:

• properly set layouts for all "container" widgets in Designer;
• create the new notes using a layout;

The first part is a bit boring at first, especially if you're trying to adapt a previously created UI, but it's a very important one.
I'm attaching a revised .ui file based on your code that already has all required layouts set and includes all alignments and size policies properly set according to your needs, but I strongly suggest you to load it in Designer and compare it with what you provided in order to understand the differences. Also consider reading more about using layouts in designer.
Basically I set:

• a generic vertical layout for the central widget (what you named MainWidget): when there's going to be only one widget, a boxed layout is generally used; while it doesn't really matter if it's vertical or horizontal, a vertical one is statistically more commonly used;
• a grid layout for the first page in the stacked widget; this allows adding the button on the left, the "title" label on the [remaining] center, and the scroll area occupying both "columns" of the layout (the whole horizontal space);
• a Maximum size policy for the "add note" button, which ensures that the widget only takes the minimum required size (the size hint is the maximum size);
• a vertical layout for the scroll area contents;
• another vertical layout that will be used as container of the "notes";
• a vertical spacer on bottom of the main layout of the scroll area, so that the "note container" will always use as much space as it needs and no more;
• a grid layout for the example note widget, with the title button aligned on the left, the "remove" button on the right, and the text label occupying both columns of the grid (similarly to the above case with the scroll area);

Note that the nested vertical layouts are only a "convenience": in reality, a single vertical layout could be used, with a spacer (a "stretch") on its bottom, and every new widget could be added by using insertWidget() with an index equal to the item count minus 1 (eg: if you have 2 widgets and you want to add another, you must use layout.insertWidget(layout.count() - 2, newWidget), since the count includes the spacer on the bottom).

Also consider that I renamed all your widgets for consistency with the standard naming convention of general programming languages (for which variables, attributes, functions and methods should always be named starting with a lower case letter); read more about it on the Style Guide for Python Code, since Python completely (and luckily) follows those conventions.

Resulting UI code: