Unify Settings Panel Design & Fix JsonRPC Settings Empty Issue #3265
Conversation
This comment has been minimized.
This comment has been minimized.
|
@onesounds Hi, I’d like to get your idea on the design for the settings panel. Which option do you think is better, or do you feel they both work well? Left aligned version:
Right aligned version:
|
@Flow-Launcher/team Hello everyone, I’d like to get your feedback on this design. What are your thoughts? |
I definitely like the left align more. With the right align, it seems unnecessary to add the separation and make it a little harder to match the label to the input. for me at least, it takes me a little bit longer to match the label to the inputs on the right align vs the left align |
|
For the check box type, left alignment is recommended, and for others, right alignment is recommended. (I referred to powertoy run and Windows 11's settings window as a reference.) I've tried to unify this a few times, but it wasn't easy because there were a lot of plug-ins with complicated settings. Anyway, the basic design recommends the Power Toy layout. |
Thanks for your reply!❤ |
Thanks for your reply!❤ I wonder why for the check box type, left alignment is recommended?
As you can see in Windows Settings, it is also right-aligned. 😢 |
NVM. I confused Toggle Button and Check Box. |
Just some personal idea: Right alignment (or justified alignemnt if you consider labels and controls as a whole line) is harder to match label and control as cibere mentioned. but windows 11 in your example image has a box containing the label and control so it's not a big deal. As in our program we don't have boxes so left alignment is better IMO. Here's an example of windows 11 using left alignment.
|
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
Jack251970
added
kind/ui
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 0
🧹 Nitpick comments (4)
Plugins/Flow.Launcher.Plugin.Explorer/Views/ExplorerSettings.xaml (2)
71-71: Avoid hardcoded margin for alignment.
Consider referencing a static resource or using a more flexible layout solution instead of"480 5 0 0"for consistency with the rest of the settings panel design.- <TextBlock Margin="480 5 0 0"> + <TextBlock Margin="{StaticResource SomeMarginResource}">
93-132: Consider reducing the large number of row definitions.
Having dozens of<RowDefinition />entries can hamper maintainability; using a more dynamic layout approach or grouping related settings might simplify future changes.Flow.Launcher/Resources/CustomControlTemplate.xaml (2)
5599-5604: Fix the spelling error in style nameThere's a typo in the style key name "SettingPanelSeperatorStyle" - it should be "SettingPanelSeparatorStyle" (with an "a" instead of "e" in "Separator").
-<Style x:Key="SettingPanelSeperatorStyle" TargetType="Separator"> +<Style x:Key="SettingPanelSeparatorStyle" TargetType="Separator">
5599-5604: Consider the relationship between margin valuesThe separator style uses negative margins that directly correspond to the values in
SettingPanelMargin(line 5590). This creates a maintenance dependency - if the panel margin changes, the separator margin would need to be updated to match.Consider either adding a comment to highlight this relationship or using a more maintainable approach like deriving these values.
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
📒 Files selected for processing (3)
Flow.Launcher.Core/Plugin/JsonRPCPluginSettings.cs(4 hunks)Flow.Launcher/Resources/CustomControlTemplate.xaml(1 hunks)Plugins/Flow.Launcher.Plugin.Explorer/Views/ExplorerSettings.xaml(3 hunks)
🔇 Additional comments (63)
Plugins/Flow.Launcher.Plugin.Explorer/Views/ExplorerSettings.xaml (39)
17-17: No further action needed for this blank line.
19-25: New style definitions look good.
No issues noted with theHeaderTextBlockStyle. Using static resources for margin aligns with the PR objective of design unification.
27-27: No further action needed for this blank line.
138-153: General settings header and checkbox layout look consistent.
These lines follow a left-aligned approach as discussed in the PR comments. Good job.
155-163: Default open in file manager option looks good.
No issues noted with binding and layout.
164-188: File Editor Path configuration is properly implemented.
TheOpenFileEditorPathcommand binding appears correct. No issues found.
190-214: Folder Editor Path configuration is consistent.
Similar approach to File Editor Path, no concerns.
216-240: Shell Path configuration is straightforward.
Binding toOpenShellPathcommand looks fine.
242-256: IndexSearchEngines ComboBox logic is clear.
Great use ofDisplayMemberPathandSelectedItem.
258-272: ContentIndexSearchEngines ComboBox logic follows the same pattern.
No issues found.
274-288: Directory Recursive Search Engine selection appears properly bound.
No concerns with data binding.
290-303: Excluded File Types setting is straightforward.
No issues noted.
305-321: Maximum Results input field is well implemented.
Preview text input check and numeric constraint seem fine.
323-329: Button for opening indexing options is properly integrated.
Command event handling looks good.
332-339: Native Context Menu header is introduced cleanly.
No issues found.
341-347: ShowWindowsContextMenu checkbox is straightforward.
Binding is correct.
349-355: Include patterns guide text is clearly presented.
No concerns here.
357-367: WindowsContextMenuIncludedItems text box is appropriately bound.
No issues to report.
369-375: Exclude patterns guide text is clear and consistent.
Good approach to help user understanding.
377-387: WindowsContextMenuExcludedItems text box binding is correct.
No issues found.
390-397: Preview Panel header is introduced properly.
Follows the established style pattern.
399-425: WrapPanel usage for file info checkboxes is consistent.
No misalignments or binding issues noted.
428-467: Date/time format combos for the preview panel are well structured.
Logic for enabling and visibility toggles is sound.
470-477: Everything Setting header is declared with consistent style usage.
No issues found.
479-487: EverythingSearchFullPath checkbox is properly bound.
No concerns.
488-496: EverythingEnableRunCount logic is straightforward.
No issues found.
497-519: Sort option combo box for Everything is well integrated.
TheEnumNameConverterusage is appropriate.
520-533: Everything installed path text box matches the other path fields.
Implementation is consistent.
535-546: Fast Sort warning message is displayed properly.
The binding and visibility approach look sound.
549-556: Customization header for Action Keywords is introduced nicely.
No issues found.
558-570: ActionKeywordsModels ListView logic is correct.
Data template usage is consistent.
572-583: Edit action keyword command is wired up properly.
Nice minimal UI approach.
586-593: Quick Access Links header follows the new style.
No further concerns.
595-613: QuickAccessLinks ListView binding is correct.
Drag and drop events are properly defined.
615-639: Button commands for removing, editing, and adding quick access links are correct.
Layout is consistent with the design approach.
642-649: IndexSearchExcludedPaths header is consistent with the rest of the design.
No issues found.
651-668: Excluded subdirectory paths ListView usage matches QuickAccessLinks pattern.
No concerns regarding the drag-and-drop configuration.
670-694: Button setup for removing, editing, and adding index search excluded paths is consistent.
No problems noted.
697-697: No further action needed for this blank line.Flow.Launcher/Resources/CustomControlTemplate.xaml (1)
5589-5615: Good implementation of standardized resources for settings panelsThe addition of these standardized resources aligns well with the PR objective to unify settings panel designs across various components. The naming conventions are consistent, and the resource types (Thickness, Style, Double) are appropriate for their intended usage.
Flow.Launcher.Core/Plugin/JsonRPCPluginSettings.cs (23)
3-3: Good addition for enhanced type safety.Adding the System.Text.Json import and enabling nullable reference types improves type safety and correctly signals that this code handles JSON elements and null values, which aligns with the refinements made to the settings handling throughout the class.
Also applies to: 11-11
22-23: Improved null handling in dictionary types.The update to use nullable object types (
object?) in both theInnerproperty andSettingsproperty is a good enhancement for type safety. This explicitly acknowledges that dictionary values can be null, which is especially important when working with JSON data.
26-26: Consistent nullable type handling for storage.The update to the
_storagefield type correctly reflects the nullable changes made to theSettingsproperty, maintaining type consistency throughout the class.
28-35: Excellent use of static resources for UI consistency.Moving hardcoded UI values to static resources referenced from the application resources is a significant improvement that supports the PR's objective of unifying the settings panel design. This approach promotes consistency across components and makes future UI adjustments more maintainable.
39-60: Enhanced initialization with robust JSON element handling.The improved initialization logic with proper null checking and type conversion from JsonElement is a significant enhancement. The switch statement based on JsonValueKind ensures values are correctly interpreted as appropriate types.
70-73: More explicit null checking for attributes.The modified null check for attributes is more explicit and safer by specifically checking for null in the name property.
75-89: Better type handling for default values.The refactored approach for handling default values with specific handling for checkboxes is more robust, ensuring correct type conversion based on the setting type.
95-98: Added consistent bracing for the early return condition.Adding explicit braces for the early return improves code consistency and reduces the risk of future bugs when additional code might be added.
140-146: Clear signaling of possible null return with nullable return type.Changing the return type to
Control?correctly signals that this method may return null. The comprehensive null checks provide clear logic for when null should be returned.
148-158: Improved grid-based layout with dynamic sizing.The updated grid configuration with auto-sized first column and star-sized second column creates a more flexible and responsive layout. Using resource-defined margins enhances consistency with the rest of the application.
175-218: Well-structured conditional panel creation.The logic for creating type-specific panels with proper labels and descriptions is clear and well-organized. The approach ensures that only appropriate controls receive labels and descriptions, improving the UI experience.
223-235: Enhanced textBlock handling with improved text wrapping.The updated textBlock implementation now properly handles line breaks and has consistent margin settings, improving readability of descriptive text in the settings panel.
238-256: Consistent styling for input fields.The input TextBox now uses resource-defined minimum width and margins, which ensures consistent appearance across the application. The event handling for text changes is straightforward and effective.
260-322: Improved file/folder input with consistent button styling.The file/folder input controls now use resource-defined dimensions and margins, with improved layout through the StackPanel. The refactored button click handler using pattern matching is more elegant and maintainable.
325-346: Better textarea implementation with appropriate dimensions.The textarea control now uses resource-defined minimum dimensions and margins, ensuring a consistent appearance with other multi-line text input areas across the application.
349-369: Consistent passwordBox styling with improved event handling.The passwordBox implementation now uses resource-defined dimensions and margins. Note the TODO comment on line 360 - this might need attention in future updates.
Could you clarify what issue the TODO on line 360 is referring to? This might need to be addressed before finalizing this PR.
372-390: Enhanced dropdown control with consistent styling.The ComboBox now uses resource-defined margins and has consistent horizontal/vertical alignment, matching the styling of other input controls.
393-414: Improved checkbox implementation with better type handling.The CheckBox now has consistent margins and improved IsChecked handling that accounts for both boolean and string representations in the settings.
415-443: Well-implemented hyperlink control with proper event handling.The hyperlink implementation is well-structured with consistent margins and proper text wrapping, improving the appearance of linked content in the settings panel.
444-453: Consistent separator styling using theme resources.The separator correctly uses a resource reference for its style, ensuring it will adapt properly to theme changes.
458-478: Logical control placement based on type.The logic for placing controls in the grid based on their type is clear and well-organized. Special cases like textBlock and separator span multiple columns, while standard controls maintain a label-input relationship across columns.
489-494: Clean UserControl wrapping.Wrapping the main grid in a UserControl is a clean approach that allows for easier integration with the rest of the application UI.
496-499: Helpful utility method for determining settings storage.Extracting the logic for determining if a setting needs to be saved into a separate method improves code readability and maintainability.
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
|
@Flow-Launcher/team Hi everyone! I have created a unified settings panel design for both preinstalled and JSON-RPC plugins. Could you spare some time to review this update? You just need to install the installer here. This installer is quick to install and fully compatible with existing Flow Launcher installations. If you do not have JSON-RPC plugins, you can use my demo plugin. You need to download and extract the files into Thank you for your time, and I would greatly appreciate your thoughts! 😊 |
btw you can just run the following command with the package manager to install it: |
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
Jack251970
changed the title
This comment has been minimized.
This comment has been minimized.
There was a problem hiding this comment.
Actionable comments posted: 0
🔭 Outside diff range comments (1)
Flow.Launcher.Core/Plugin/JsonRPCPluginSettings.cs (1)
146-146: 🛠️ Refactor suggestionUpdate method signature to reflect nullable return.
The method can potentially return null when NeedCreateSettingPanel() is false, but the return type doesn't reflect this.
-public Control CreateSettingPanel() +public Control? CreateSettingPanel()
🧹 Nitpick comments (2)
Flow.Launcher.Core/Plugin/JsonRPCPluginSettings.cs (2)
95-98: Minor formatting inconsistency.The braces for the if-statement are now on separate lines, which differs from the style used in the rest of the file. Consider making this consistent.
if (settings == null || settings.Count == 0) -{ return; -}
139-139: Remove trailing whitespace.There's an unnecessary trailing whitespace on line 139.
- +
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
📒 Files selected for processing (2)
Flow.Launcher.Core/Plugin/JsonRPCPluginSettings.cs(5 hunks)Plugins/Flow.Launcher.Plugin.Sys/SysSettings.xaml(1 hunks)
🚧 Files skipped from review as they are similar to previous changes (1)
- Plugins/Flow.Launcher.Plugin.Sys/SysSettings.xaml
⏰ Context from checks skipped due to timeout of 90000ms (1)
- GitHub Check: gitStream.cm
🔇 Additional comments (22)
Flow.Launcher.Core/Plugin/JsonRPCPluginSettings.cs (22)
3-3: Good addition of nullable context and JSON namespace.The addition of
System.Text.Jsonnamespace and the#nullable enabledirective align with modern C# best practices for null safety and JSON element handling in the updated code.Also applies to: 10-11
22-23: Improved type safety with nullable annotations.The change to use nullable references (
object?) for dictionary values enhances type safety and aligns with the nullable annotation context. This allows for explicit handling of null values in settings.Also applies to: 26-26
28-35: Good extraction of hardcoded values to static resources.Replacing hardcoded UI metrics with application resources improves consistency and maintainability. This change supports the PR's objective of unifying the settings panel design across components.
39-60: Improved initialization with null checks and type conversion.The enhancement of
InitializeAsyncwith proper null checks and JsonElement conversion is excellent. This resolves issues with type handling when loading settings from JSON files.
150-159: Good use of resource references for panel creation.The panel creation now uses the static resources for margins and other UI properties, which is consistent with the PR's goal of unifying the design.
178-180: Good use of nullable annotation for panel variable.The explicit nullable annotation for the panel variable is consistent with the nullable context and improves type safety.
185-220: Improved layout structure with better organization.The panel creation logic is now better organized with consistent margins and alignment properties from the application resources.
226-236: Good use of resource references for TextBlock.The TextBlock creation now uses proper margins and layout properties from application resources.
240-256: Good use of resource references for TextBox.The TextBox now uses consistent MinWidth and Margin from application resources.
262-275: Good use of resource references for path input TextBox.The path TextBox now uses Width and Margin from application resources.
278-282: Good use of resource references for Button.The Button now uses consistent Margin from application resources.
287-307: Improved dialog handling with pattern matching.The dialog handling code has been improved with pattern matching for different dialog types, making the code more readable and maintainable.
309-321: Good use of resource references for StackPanel.The StackPanel now uses consistent Margin from application resources.
327-347: Good use of resource references for TextArea.The TextArea now uses consistent MinHeight, MinWidth, and Margin from application resources.
351-369: Good use of resource references for PasswordBox.The PasswordBox now uses consistent MinWidth and Margin from application resources.
373-390: Good use of resource references for ComboBox.The ComboBox now uses consistent Margin from application resources.
394-412: Good use of resource references for CheckBox.The CheckBox now uses consistent Margin from application resources.
417-444: Good implementation of hyperlink with consistent styling.The hyperlink implementation is well-structured and uses consistent Margin from application resources.
445-454: Good implementation of separator with consistent styling.The separator implementation uses a resource reference for its style, which is consistent with the PR's goal of unifying design.
460-485: Good panel and control placement logic.The logic for placing controls in the grid is well-structured and consistent, with proper handling for both panel-less controls and controls with panels.
491-494: Good use of UserControl wrapper.Wrapping the main grid in a UserControl provides a clean interface for the settings panel.
497-499: Good extraction of type checking logic.The extraction of the
NeedSaveInSettingsmethod improves code reuse and readability by centralizing the logic for determining which control types need to be saved.
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
There was a problem hiding this comment.
Actionable comments posted: 2
🔭 Outside diff range comments (1)
Flow.Launcher.Core/Plugin/JsonRPCPluginSettings.cs (1)
145-145:⚠️ Potential issueUpdate method signature to reflect nullable return type.
The method implementation shows this method can return null (when checking NeedCreateSettingPanel()), but the signature doesn't reflect this possibility.
- public Control CreateSettingPanel() + public Control? CreateSettingPanel()
🧹 Nitpick comments (3)
Flow.Launcher/Resources/CustomControlTemplate.xaml (1)
5599-5604: Fixed a typo in the style key name.There's a typo in the style key name - "Seperator" should be "Separator".
-<Style x:Key="SettingPanelSeperatorStyle" TargetType="Separator"> +<Style x:Key="SettingPanelSeparatorStyle" TargetType="Separator">Additionally, consider documenting why the negative margins (-70 and -18) are needed in this style to help future maintainers understand the design decision.
Flow.Launcher.Core/Plugin/JsonRPCPluginSettings.cs (2)
489-492: Consider adding ScrollViewer for better user experience with many settings.When a plugin has many settings, users may need to scroll to access all options. Wrapping the content in a ScrollViewer would improve usability.
- return new UserControl() - { - Content = mainPanel - }; + return new UserControl() + { + Content = new ScrollViewer() + { + VerticalScrollBarVisibility = ScrollBarVisibility.Auto, + Content = mainPanel + } + };
271-274: Consider unsubscribing event handlers to prevent memory leaks.The event handlers are created and attached but never detached, which could cause memory leaks if these controls are frequently created and disposed.
Consider implementing IDisposable on the class or adding a method to unsubscribe these event handlers when the settings panel is no longer needed.
Also applies to: 338-341, 360-363, 381-384, 405-408
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
📒 Files selected for processing (3)
Flow.Launcher.Core/Plugin/JsonRPCPluginSettings.cs(5 hunks)Flow.Launcher/Resources/CustomControlTemplate.xaml(1 hunks)Plugins/Flow.Launcher.Plugin.Explorer/Views/ExplorerSettings.xaml(3 hunks)
🔇 Additional comments (20)
Plugins/Flow.Launcher.Plugin.Explorer/Views/ExplorerSettings.xaml (8)
19-26: Well-designed reusable style for section headers.The new
HeaderTextBlockStyleimplementation is a good practice for maintaining consistency across section headers in the settings panel. This matches the PR's objective of unifying design across settings panels.
93-136: Excellent structure change from tabbed to grid layout.The transition from a tabbed interface to a unified grid layout with consistent column definitions improves usability by presenting all settings in a single scrollable view. The two-column layout with labels in the first column and controls in the second creates a clean, organized appearance.
138-330: Consistent use of margin resources enhances maintainability.The consistent application of static resources for margins (like
SettingPanelMargin,SettingPanelItemTopBottomMargin, etc.) rather than hardcoded values significantly improves maintainability. This allows for centralized styling adjustments across all settings panels.
407-424: Good use of WrapPanel for checkbox grouping.The WrapPanel implementation for grouping related checkboxes in the Preview Panel section is a good approach for responsive design, allowing the UI to adapt to different window sizes while keeping related options together.
438-465: Responsive design with appropriate visibility binding.The Preview Panel date and time format section properly implements visibility binding and enabled states based on user selections, showing good attention to conditional UI interactions.
467-544: Well-structured section with appropriate warnings.The Everything Setting section demonstrates good UX by including visual warnings (orange text) when certain options might have performance implications. The organization of settings follows a logical flow.
583-637: Consistent UI pattern for list management.The Quick Access Links section follows a consistent pattern with other list management sections, providing a standardized approach for list views with add/edit/delete operations. This pattern is repeated in other sections, reinforcing UI predictability.
639-692: Maintained consistency in final section.The Index Search Excluded Paths section maintains the same pattern established in previous list sections, further reinforcing design consistency throughout the settings panel.
Flow.Launcher/Resources/CustomControlTemplate.xaml (5)
5589-5590: Good addition of a dedicated Settings Panel section.Adding a clear section header for the Settings Panel styles improves code organization and maintainability.
5590-5591: Well-defined margin resource for the settings panel.Creating a standardized margin for the settings panel will help maintain consistent spacing across all plugin settings panels.
5592-5597: Good organization of directional margin resources.These margin resources provide a comprehensive set of options for different UI element positioning needs within the settings panel. The naming convention clearly indicates the directional application of each margin.
5606-5608: Well-defined size constants for text elements.These standardized sizes will ensure consistent appearance of TextBox controls across all plugin settings panels.
5610-5614: Good description style for settings panels.This style defines a clear visual distinction for description text in settings panels. The smaller font size and different color will help separate descriptions from primary content.
Flow.Launcher.Core/Plugin/JsonRPCPluginSettings.cs (7)
3-3: Good addition of nullable support and JSON handling.The addition of
#nullable enableand the System.Text.Json namespace import enhances type safety and properly supports JSON parsing for settings values.Also applies to: 11-11
22-23: Well-implemented nullability for settings collections.Updating the dictionary types to support nullable values (
object?) more accurately represents that settings can have null values, improving type safety and making the code more robust.Also applies to: 26-26
28-34: Good practice using static resource references for UI consistency.Extracting UI element properties from application resources rather than hardcoding values ensures consistent appearance across the application and simplifies future updates.
38-59: Improved settings initialization with robust null handling.The enhanced initialization logic now properly handles null settings and correctly converts JsonElement values to their appropriate types. This fixes potential issues with empty settings and improves type consistency.
149-159: Well-structured grid layout for the settings panel.The grid-based approach with proper column definitions provides a more consistent and flexible layout structure compared to the previous implementation.
457-477: Good implementation of conditional layout logic.The conditional layout logic that handles different types of UI elements (with or without labels) ensures proper positioning in the grid and creates a consistent visual experience.
495-498: Well-extracted helper method for better code organization.Extracting the
NeedSaveInSettingslogic into a separate method improves code readability and maintainability.
@check-spelling-bot Report🔴 Please reviewSee the 📂 files view, the 📜action log, or 📝 job summary for details.
See ❌ Event descriptions for more information. If the flagged items are 🤯 false positivesIf items relate to a ...
|
There was a problem hiding this comment.
Actionable comments posted: 0
♻️ Duplicate comments (1)
Flow.Launcher.Core/Plugin/JsonRPCPluginSettings.cs (1)
414-417: 🛠️ Refactor suggestionPrevent potential NullReferenceException in checkbox event handler.
The code uses the null-forgiving operator (
!) when accessingIsChecked, but it's safer to use the null-coalescing operator (??) instead sinceIsCheckedis a nullable boolean.- Settings[attributes.Name] = ((CheckBox)sender).IsChecked ?? defaultValue; + Settings[attributes.Name] = ((CheckBox)sender).IsChecked ?? false;
🧹 Nitpick comments (1)
Flow.Launcher.Core/Plugin/JsonRPCPluginSettings.cs (1)
154-155: Uncomment or remove the redundant NeedCreateSettingPanel check.The commented code is unnecessary since, as the comment above notes, this method is only called if
NeedCreateSettingPanel()is true. Consider either removing the commented line or uncommenting it for defensive programming if there's a possibility the method could be called incorrectly.- // No need to check if NeedCreateSettingPanel is true because CreateSettingPanel will only be called if it's true - // if (!NeedCreateSettingPanel()) return null; + // No need to check if NeedCreateSettingPanel is true because CreateSettingPanel will only be called if it's true
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
📒 Files selected for processing (1)
Flow.Launcher.Core/Plugin/JsonRPCPluginSettings.cs(6 hunks)
⏰ Context from checks skipped due to timeout of 90000ms (1)
- GitHub Check: gitStream.cm
🔇 Additional comments (16)
Flow.Launcher.Core/Plugin/JsonRPCPluginSettings.cs (16)
11-11: Good use of nullable annotation context.Enabling nullable reference types helps catch potential null reference exceptions at compile time, which aligns with best practices for modern C# development.
22-23: Important type safety improvement with nullable references.The change from
objecttoobject?in bothInnerandSettingsproperties correctly acknowledges that values in the settings dictionary can be null. This ensures type safety and aligns with the nullable reference types feature.
26-26: Properly updated storage type to match the nullable pattern.Updating the
_storagefield type to useobject?maintains consistency with theSettingsproperty changes.
28-34: Good refactoring of UI constants to use application resources.Extracting UI constants from hardcoded values to application resources improves maintainability and ensures consistent styling across the application. This supports the PR objective of unifying settings panel design.
38-59: Improved initialization with robust null checks and type conversions.The null check for Settings and the explicit conversion of JsonElement values to their appropriate types significantly improves the robustness of settings initialization. The switch statement properly handles different JSON value kinds.
69-70: More explicit null check for setting attributes.The comment clarifies the reason for skipping settings without attributes or names, which improves code readability.
74-88: Enhanced settings initialization with improved comments and null safety.The code now explicitly checks for settings that need to be saved and ensures they exist with appropriate default values. The conditional logic for checkbox values is particularly well handled.
95-98: Clear early return pattern for empty settings.Using early return when settings are null or empty is a good practice that simplifies the method flow.
109-110: Improved null handling for text-based controls.Using the null-coalescing operator (
??) to provide an empty string default improves robustness. The string type check before assignment handles potential type mismatches gracefully.Also applies to: 113-114
120-126: Robust boolean value handling with pattern matching.The code for handling checkbox values now properly accounts for different value types using pattern matching and explicit boolean conversion, which is more robust than before.
157-165: Well-structured grid layout with proper column definitions.Using auto-sizing for the label column and star-sizing for the content column is a good approach that allows the UI to adapt to different content sizes and window widths.
187-226: Improved panel creation logic with clear conditional structure.The conditional creation of panels based on control type improves the code organization and readability. The use of resource references for styles ensures consistent appearance across the application.
423-451: Well-implemented hyperlink control with proper navigation handling.The hyperlink implementation correctly uses the API's OpenUrl method and properly handles the navigation event. The UI properties are consistently styled with the rest of the controls.
467-486: Logical grid layout with appropriate column and row spanning.The code correctly places controls in the grid based on their type, using column spanning for full-width controls like textBlock and separator. This creates a clean and consistent UI layout.
497-502: Clean implementation of the settings panel.Wrapping the grid in a UserControl provides a clean interface for the settings panel and follows WPF best practices.
504-507: Extracted reusable logic into a helper method.Moving the type check logic into a separate method improves code maintainability and reusability. The method name clearly describes its purpose.
Unify settings panel design
Unify desgin in
InstalledPluginDisplayKeyword.xaml,JsonRPCPluginSettings.csand settings panel xaml files of all plugins. All designed resources are inCustomControlTemplate.xaml.Also fix JsonRPC plugin settings empty issues in
JsonRPCSettings.cs. (Since this is import part for testing JsonRPC settings panel, I put it in this PR)Fix:#2577, #3182 (
InitializeAsync())TODO list
Test