From 7bfd1ecf80b4d0bd5a64ebf3f8a46932bef92c48 Mon Sep 17 00:00:00 2001 From: Seth Hillbrand Date: Wed, 21 Jan 2026 15:44:39 -0800 Subject: [PATCH] Update themed svgs --- common/bitmap_info.cpp | 74 +++ include/bitmaps/bitmaps_list.h | 5 +- pcbnew/CMakeLists.txt | 12 + .../drc_re_abs_length_two_constraint_data.h | 13 + .../drc_re_abs_length_two_overlay_panel.cpp | 117 ++++ .../drc_re_abs_length_two_overlay_panel.h | 68 +++ ...c_re_allowed_orientation_constraint_data.h | 16 + ...c_re_allowed_orientation_overlay_panel.cpp | 128 +++++ ...drc_re_allowed_orientation_overlay_panel.h | 61 ++ .../rule_editor/drc_re_base_constraint_data.h | 21 + .../drc_re_bitmap_overlay_panel.cpp | 299 ++++++++++ .../rule_editor/drc_re_bitmap_overlay_panel.h | 238 ++++++++ .../drc_re_bool_input_constraint_data.h | 11 + .../drc_re_bool_input_overlay_panel.cpp | 98 ++++ .../drc_re_bool_input_overlay_panel.h | 57 ++ .../rule_editor/drc_re_content_panel_base.h | 3 + .../drc_re_min_txt_ht_th_constraint_data.h | 15 + .../drc_re_min_txt_ht_th_overlay_panel.cpp | 113 ++++ .../drc_re_min_txt_ht_th_overlay_panel.h | 67 +++ .../drc_re_numeric_input_constraint_data.h | 11 + .../drc_re_numeric_input_overlay_panel.cpp | 103 ++++ .../drc_re_numeric_input_overlay_panel.h | 66 +++ .../drc_re_numeric_input_panel.cpp | 6 +- .../drc/rule_editor/drc_re_overlay_field.cpp | 154 +++++ pcbnew/drc/rule_editor/drc_re_overlay_field.h | 174 ++++++ .../drc_re_overlay_panel_factory.cpp | 116 ++++ .../drc_re_overlay_panel_factory.h | 67 +++ pcbnew/drc/rule_editor/drc_re_overlay_types.h | 82 +++ .../drc_re_permitted_layers_constraint_data.h | 12 + .../drc_re_permitted_layers_overlay_panel.cpp | 104 ++++ .../drc_re_permitted_layers_overlay_panel.h | 58 ++ .../drc_re_routing_width_constraint_data.h | 13 + .../drc_re_routing_width_overlay_panel.cpp | 125 ++++ .../drc_re_routing_width_overlay_panel.h | 68 +++ .../drc_re_rtg_diff_pair_constraint_data.h | 17 + .../drc_re_rtg_diff_pair_overlay_panel.cpp | 157 ++++++ .../drc_re_rtg_diff_pair_overlay_panel.h | 71 +++ .../drc_re_via_style_constraint_data.h | 16 + .../drc_re_via_style_overlay_panel.cpp | 150 +++++ .../drc_re_via_style_overlay_panel.h | 74 +++ .../drc/rule_editor/panel_drc_rule_editor.cpp | 106 ++-- qa/tests/pcbnew/CMakeLists.txt | 1 + .../drc/test_drc_bitmap_overlay_panel.cpp | 532 ++++++++++++++++++ resources/bitmaps_png/CMakeLists.txt | 103 ++++ .../generate_themed_constraints.py | 120 ++++ .../png/constraint_absolute_length_2.png | Bin 0 -> 1951 bytes .../png/constraint_absolute_length_2_dark.png | Bin 0 -> 1987 bytes .../png/constraint_allowed_orientation.png | Bin 5545 -> 6679 bytes .../constraint_allowed_orientation_dark.png | Bin 0 -> 6621 bytes .../png/constraint_basic_clearance.png | Bin 1881 -> 3090 bytes .../png/constraint_basic_clearance_dark.png | Bin 0 -> 3114 bytes .../constraint_board_outline_clearance.png | Bin 1731 -> 2258 bytes ...onstraint_board_outline_clearance_dark.png | Bin 0 -> 2321 bytes .../bitmaps_png/png/constraint_clearance.png | Bin 0 -> 2764 bytes .../png/constraint_clearance_dark.png | Bin 0 -> 3232 bytes .../constraint_copper_to_edge_clearance.png | Bin 8515 -> 4532 bytes ...nstraint_copper_to_edge_clearance_dark.png | Bin 0 -> 4582 bytes .../constraint_copper_to_hole_clearance.png | Bin 8708 -> 518 bytes ...nstraint_copper_to_hole_clearance_dark.png | Bin 0 -> 522 bytes .../png/constraint_creepage_distance.png | Bin 4294 -> 5472 bytes .../png/constraint_creepage_distance_dark.png | Bin 0 -> 5534 bytes .../bitmaps_png/png/constraint_hole_size.png | Bin 2132 -> 2880 bytes .../png/constraint_hole_size_dark.png | Bin 0 -> 2963 bytes .../png/constraint_hole_to_hole_clearance.png | Bin 11880 -> 543 bytes ...constraint_hole_to_hole_clearance_dark.png | Bin 0 -> 549 bytes .../png/constraint_hole_to_hole_distance.png | Bin 2756 -> 3657 bytes .../constraint_hole_to_hole_distance_dark.png | Bin 0 -> 3700 bytes .../bitmaps_png/png/constraint_length.png | Bin 0 -> 2230 bytes .../png/constraint_length_dark.png | Bin 0 -> 2347 bytes .../constraint_matched_length_diff_pair.png | Bin 0 -> 6669 bytes ...nstraint_matched_length_diff_pair_dark.png | Bin 0 -> 6669 bytes .../constraint_maximum_allowed_deviation.png | Bin 7748 -> 349 bytes ...straint_maximum_allowed_deviation_dark.png | Bin 0 -> 359 bytes .../png/constraint_maximum_via_count.png | Bin 2530 -> 5016 bytes .../png/constraint_maximum_via_count_dark.png | Bin 0 -> 5005 bytes .../png/constraint_minimum_angular_ring.png | Bin 3171 -> 4427 bytes .../constraint_minimum_angular_ring_dark.png | Bin 0 -> 4473 bytes .../png/constraint_minimum_annular_width.png | Bin 9426 -> 463 bytes .../constraint_minimum_annular_width_dark.png | Bin 0 -> 459 bytes .../png/constraint_minimum_clearance.png | Bin 8443 -> 409 bytes .../png/constraint_minimum_clearance_dark.png | Bin 0 -> 410 bytes .../constraint_minimum_connection_width.png | Bin 10946 -> 545 bytes ...nstraint_minimum_connection_width_dark.png | Bin 0 -> 537 bytes .../png/constraint_minimum_item_clearance.png | Bin 7778 -> 505 bytes ...constraint_minimum_item_clearance_dark.png | Bin 0 -> 510 bytes .../constraint_minimum_soldermask_silver.png | Bin 5275 -> 6679 bytes ...straint_minimum_soldermask_silver_dark.png | Bin 0 -> 6536 bytes ...aint_minimum_text_height_and_thickness.png | Bin 3173 -> 256 bytes ...minimum_text_height_and_thickness_dark.png | Bin 0 -> 262 bytes ...int_minimum_thermal_relief_spoke_count.png | Bin 12658 -> 8400 bytes ...inimum_thermal_relief_spoke_count_dark.png | Bin 0 -> 8320 bytes .../png/constraint_minimum_through_hole.png | Bin 9295 -> 467 bytes .../constraint_minimum_through_hole_dark.png | Bin 0 -> 465 bytes .../png/constraint_minimum_track_width.png | Bin 5908 -> 332 bytes .../constraint_minimum_track_width_dark.png | Bin 0 -> 329 bytes .../png/constraint_minimum_uvia_diameter.png | Bin 8860 -> 410 bytes .../constraint_minimum_uvia_diameter_dark.png | Bin 0 -> 408 bytes .../png/constraint_minimum_uvia_hole.png | Bin 8623 -> 421 bytes .../png/constraint_minimum_uvia_hole_dark.png | Bin 0 -> 419 bytes .../png/constraint_minimum_via_diameter.png | Bin 9547 -> 457 bytes .../constraint_minimum_via_diameter_dark.png | Bin 0 -> 454 bytes .../png/constraint_permitted_layers.png | Bin 1795 -> 2711 bytes .../png/constraint_permitted_layers_dark.png | Bin 0 -> 2677 bytes .../png/constraint_routing_diff_pair.png | Bin 6062 -> 7198 bytes .../png/constraint_routing_diff_pair_dark.png | Bin 0 -> 7499 bytes .../png/constraint_routing_width.png | Bin 1724 -> 2537 bytes .../png/constraint_routing_width_dark.png | Bin 0 -> 2626 bytes .../png/constraint_silk_clearance.png | Bin 0 -> 515 bytes .../png/constraint_silk_clearance_dark.png | Bin 0 -> 512 bytes ...onstraint_silk_to_soldermask_clearance.png | Bin 6101 -> 7757 bytes ...aint_silk_to_soldermask_clearance_dark.png | Bin 0 -> 7534 bytes .../png/constraint_soldermask_expansion.png | Bin 3920 -> 5197 bytes .../constraint_soldermask_expansion_dark.png | Bin 0 -> 5366 bytes .../png/constraint_solderpaste_expansion.png | Bin 1760 -> 2646 bytes .../constraint_solderpaste_expansion_dark.png | Bin 0 -> 2756 bytes .../bitmaps_png/png/constraint_via_style.png | Bin 2648 -> 4122 bytes .../png/constraint_via_style_dark.png | Bin 0 -> 4257 bytes .../png/constraint_vias_under_smd.png | Bin 0 -> 4311 bytes .../png/constraint_vias_under_smd_dark.png | Bin 0 -> 4311 bytes .../sources/constraints/absolute-lenght.svg | 87 ++- .../dark/constraints/absolute-length-2.svg | 138 +++++ .../dark/constraints/allowed-orientation.svg | 239 ++++++++ .../dark/constraints/basic-clearance.svg | 156 +++++ .../constraints/board-outline-clearance.svg | 144 +++++ .../sources/dark/constraints/clearance.svg | 159 ++++++ .../constraints/copper-to-hole-clearance.svg | 182 ++++++ .../constraints/copper_to_edge_clearance.svg | 293 ++++++++++ .../dark/constraints/creepage-distance.svg | 295 ++++++++++ .../sources/dark/constraints/hole-size.svg | 178 ++++++ .../constraints/hole-to-hole-clearance.svg | 210 +++++++ .../constraints/hole-to-hole-distance.svg | 119 ++++ .../sources/dark/constraints/length.svg | 203 +++++++ .../constraints/matched-length-diff-pair.svg | 137 +++++ .../constraints/maximum-allowed-deviation.svg | 175 ++++++ .../dark/constraints/maximum-via-count.svg | 235 ++++++++ .../dark/constraints/minimum-angular-ring.svg | 105 ++++ .../constraints/minimum-annular-width.svg | 182 ++++++ .../dark/constraints/minimum-clearance.svg | 195 +++++++ .../constraints/minimum-connection-width.svg | 274 +++++++++ .../constraints/minimum-item-clearance.svg | 193 +++++++ .../constraints/minimum-soldermask-silver.svg | 202 +++++++ .../minimum-text-height-and-thickness.svg | 194 +++++++ .../dark/constraints/minimum-through-hole.svg | 182 ++++++ .../dark/constraints/minimum-track-width.svg | 190 +++++++ .../constraints/minimum-uvia-diameter.svg | 177 ++++++ .../dark/constraints/minimum-uvia-hole.svg | 177 ++++++ .../dark/constraints/minimum-via-diameter.svg | 185 ++++++ .../minimum_thermal_relief_spoke_count.svg | 457 +++++++++++++++ .../dark/constraints/permitted-layers.svg | 409 ++++++++++++++ .../dark/constraints/routing-diff-pair.svg | 377 +++++++++++++ .../dark/constraints/routing-width.svg | 248 ++++++++ .../silk-to-soldermask-clearance.svg | 190 +++++++ .../dark/constraints/silk_clearance.svg | 292 ++++++++++ .../dark/constraints/soldermask-expansion.svg | 160 ++++++ .../constraints/solderpaste-expansion.svg | 145 +++++ .../sources/dark/constraints/via-style.svg | 123 ++++ .../dark/constraints/vias-under-smd.svg | 102 ++++ .../light/constraints/absolute-length-2.svg | 138 +++++ .../light/constraints/allowed-orientation.svg | 239 ++++++++ .../light/constraints/basic-clearance.svg | 156 +++++ .../constraints/board-outline-clearance.svg | 144 +++++ .../sources/light/constraints/clearance.svg | 157 ++++++ .../constraints/copper-to-hole-clearance.svg | 182 ++++++ .../constraints/copper_to_edge_clearance.svg | 293 ++++++++++ .../light/constraints/creepage-distance.svg | 295 ++++++++++ .../sources/light/constraints/hole-size.svg | 178 ++++++ .../constraints/hole-to-hole-clearance.svg | 210 +++++++ .../constraints/hole-to-hole-distance.svg | 119 ++++ .../sources/light/constraints/length.svg | 203 +++++++ .../constraints/matched-length-diff-pair.svg | 137 +++++ .../constraints/maximum-allowed-deviation.svg | 175 ++++++ .../light/constraints/maximum-via-count.svg | 231 ++++++++ .../constraints/minimum-angular-ring.svg | 105 ++++ .../constraints/minimum-annular-width.svg | 182 ++++++ .../light/constraints/minimum-clearance.svg | 195 +++++++ .../constraints/minimum-connection-width.svg | 274 +++++++++ .../constraints/minimum-item-clearance.svg | 193 +++++++ .../constraints/minimum-soldermask-silver.svg | 202 +++++++ .../minimum-text-height-and-thickness.svg | 194 +++++++ .../constraints/minimum-through-hole.svg | 182 ++++++ .../light/constraints/minimum-track-width.svg | 190 +++++++ .../constraints/minimum-uvia-diameter.svg | 177 ++++++ .../light/constraints/minimum-uvia-hole.svg | 177 ++++++ .../constraints/minimum-via-diameter.svg | 185 ++++++ .../minimum_thermal_relief_spoke_count.svg | 457 +++++++++++++++ .../light/constraints/permitted-layers.svg | 409 ++++++++++++++ .../light/constraints/routing-diff-pair.svg | 379 +++++++++++++ .../light/constraints/routing-width.svg | 248 ++++++++ .../silk-to-soldermask-clearance.svg | 190 +++++++ .../light/constraints/silk_clearance.svg | 292 ++++++++++ .../constraints/soldermask-expansion.svg | 160 ++++++ .../constraints/solderpaste-expansion.svg | 145 +++++ .../sources/light/constraints/via-style.svg | 123 ++++ .../light/constraints/vias-under-smd.svg | 102 ++++ 194 files changed, 19175 insertions(+), 74 deletions(-) create mode 100644 pcbnew/drc/rule_editor/drc_re_abs_length_two_overlay_panel.cpp create mode 100644 pcbnew/drc/rule_editor/drc_re_abs_length_two_overlay_panel.h create mode 100644 pcbnew/drc/rule_editor/drc_re_allowed_orientation_overlay_panel.cpp create mode 100644 pcbnew/drc/rule_editor/drc_re_allowed_orientation_overlay_panel.h create mode 100644 pcbnew/drc/rule_editor/drc_re_bitmap_overlay_panel.cpp create mode 100644 pcbnew/drc/rule_editor/drc_re_bitmap_overlay_panel.h create mode 100644 pcbnew/drc/rule_editor/drc_re_bool_input_overlay_panel.cpp create mode 100644 pcbnew/drc/rule_editor/drc_re_bool_input_overlay_panel.h create mode 100644 pcbnew/drc/rule_editor/drc_re_min_txt_ht_th_overlay_panel.cpp create mode 100644 pcbnew/drc/rule_editor/drc_re_min_txt_ht_th_overlay_panel.h create mode 100644 pcbnew/drc/rule_editor/drc_re_numeric_input_overlay_panel.cpp create mode 100644 pcbnew/drc/rule_editor/drc_re_numeric_input_overlay_panel.h create mode 100644 pcbnew/drc/rule_editor/drc_re_overlay_field.cpp create mode 100644 pcbnew/drc/rule_editor/drc_re_overlay_field.h create mode 100644 pcbnew/drc/rule_editor/drc_re_overlay_panel_factory.cpp create mode 100644 pcbnew/drc/rule_editor/drc_re_overlay_panel_factory.h create mode 100644 pcbnew/drc/rule_editor/drc_re_overlay_types.h create mode 100644 pcbnew/drc/rule_editor/drc_re_permitted_layers_overlay_panel.cpp create mode 100644 pcbnew/drc/rule_editor/drc_re_permitted_layers_overlay_panel.h create mode 100644 pcbnew/drc/rule_editor/drc_re_routing_width_overlay_panel.cpp create mode 100644 pcbnew/drc/rule_editor/drc_re_routing_width_overlay_panel.h create mode 100644 pcbnew/drc/rule_editor/drc_re_rtg_diff_pair_overlay_panel.cpp create mode 100644 pcbnew/drc/rule_editor/drc_re_rtg_diff_pair_overlay_panel.h create mode 100644 pcbnew/drc/rule_editor/drc_re_via_style_overlay_panel.cpp create mode 100644 pcbnew/drc/rule_editor/drc_re_via_style_overlay_panel.h create mode 100644 qa/tests/pcbnew/drc/test_drc_bitmap_overlay_panel.cpp create mode 100644 resources/bitmaps_png/generate_themed_constraints.py create mode 100644 resources/bitmaps_png/png/constraint_absolute_length_2.png create mode 100644 resources/bitmaps_png/png/constraint_absolute_length_2_dark.png create mode 100644 resources/bitmaps_png/png/constraint_allowed_orientation_dark.png create mode 100644 resources/bitmaps_png/png/constraint_basic_clearance_dark.png create mode 100644 resources/bitmaps_png/png/constraint_board_outline_clearance_dark.png create mode 100644 resources/bitmaps_png/png/constraint_clearance.png create mode 100644 resources/bitmaps_png/png/constraint_clearance_dark.png create mode 100644 resources/bitmaps_png/png/constraint_copper_to_edge_clearance_dark.png create mode 100644 resources/bitmaps_png/png/constraint_copper_to_hole_clearance_dark.png create mode 100644 resources/bitmaps_png/png/constraint_creepage_distance_dark.png create mode 100644 resources/bitmaps_png/png/constraint_hole_size_dark.png create mode 100644 resources/bitmaps_png/png/constraint_hole_to_hole_clearance_dark.png create mode 100644 resources/bitmaps_png/png/constraint_hole_to_hole_distance_dark.png create mode 100644 resources/bitmaps_png/png/constraint_length.png create mode 100644 resources/bitmaps_png/png/constraint_length_dark.png create mode 100644 resources/bitmaps_png/png/constraint_matched_length_diff_pair.png create mode 100644 resources/bitmaps_png/png/constraint_matched_length_diff_pair_dark.png create mode 100644 resources/bitmaps_png/png/constraint_maximum_allowed_deviation_dark.png create mode 100644 resources/bitmaps_png/png/constraint_maximum_via_count_dark.png create mode 100644 resources/bitmaps_png/png/constraint_minimum_angular_ring_dark.png create mode 100644 resources/bitmaps_png/png/constraint_minimum_annular_width_dark.png create mode 100644 resources/bitmaps_png/png/constraint_minimum_clearance_dark.png create mode 100644 resources/bitmaps_png/png/constraint_minimum_connection_width_dark.png create mode 100644 resources/bitmaps_png/png/constraint_minimum_item_clearance_dark.png create mode 100644 resources/bitmaps_png/png/constraint_minimum_soldermask_silver_dark.png create mode 100644 resources/bitmaps_png/png/constraint_minimum_text_height_and_thickness_dark.png create mode 100644 resources/bitmaps_png/png/constraint_minimum_thermal_relief_spoke_count_dark.png create mode 100644 resources/bitmaps_png/png/constraint_minimum_through_hole_dark.png create mode 100644 resources/bitmaps_png/png/constraint_minimum_track_width_dark.png create mode 100644 resources/bitmaps_png/png/constraint_minimum_uvia_diameter_dark.png create mode 100644 resources/bitmaps_png/png/constraint_minimum_uvia_hole_dark.png create mode 100644 resources/bitmaps_png/png/constraint_minimum_via_diameter_dark.png create mode 100644 resources/bitmaps_png/png/constraint_permitted_layers_dark.png create mode 100644 resources/bitmaps_png/png/constraint_routing_diff_pair_dark.png create mode 100644 resources/bitmaps_png/png/constraint_routing_width_dark.png create mode 100644 resources/bitmaps_png/png/constraint_silk_clearance.png create mode 100644 resources/bitmaps_png/png/constraint_silk_clearance_dark.png create mode 100644 resources/bitmaps_png/png/constraint_silk_to_soldermask_clearance_dark.png create mode 100644 resources/bitmaps_png/png/constraint_soldermask_expansion_dark.png create mode 100644 resources/bitmaps_png/png/constraint_solderpaste_expansion_dark.png create mode 100644 resources/bitmaps_png/png/constraint_via_style_dark.png create mode 100644 resources/bitmaps_png/png/constraint_vias_under_smd.png create mode 100644 resources/bitmaps_png/png/constraint_vias_under_smd_dark.png create mode 100644 resources/bitmaps_png/sources/dark/constraints/absolute-length-2.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/allowed-orientation.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/basic-clearance.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/board-outline-clearance.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/clearance.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/copper-to-hole-clearance.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/copper_to_edge_clearance.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/creepage-distance.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/hole-size.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/hole-to-hole-clearance.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/hole-to-hole-distance.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/length.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/matched-length-diff-pair.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/maximum-allowed-deviation.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/maximum-via-count.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/minimum-angular-ring.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/minimum-annular-width.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/minimum-clearance.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/minimum-connection-width.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/minimum-item-clearance.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/minimum-soldermask-silver.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/minimum-text-height-and-thickness.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/minimum-through-hole.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/minimum-track-width.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/minimum-uvia-diameter.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/minimum-uvia-hole.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/minimum-via-diameter.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/minimum_thermal_relief_spoke_count.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/permitted-layers.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/routing-diff-pair.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/routing-width.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/silk-to-soldermask-clearance.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/silk_clearance.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/soldermask-expansion.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/solderpaste-expansion.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/via-style.svg create mode 100644 resources/bitmaps_png/sources/dark/constraints/vias-under-smd.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/absolute-length-2.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/allowed-orientation.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/basic-clearance.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/board-outline-clearance.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/clearance.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/copper-to-hole-clearance.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/copper_to_edge_clearance.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/creepage-distance.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/hole-size.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/hole-to-hole-clearance.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/hole-to-hole-distance.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/length.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/matched-length-diff-pair.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/maximum-allowed-deviation.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/maximum-via-count.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/minimum-angular-ring.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/minimum-annular-width.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/minimum-clearance.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/minimum-connection-width.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/minimum-item-clearance.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/minimum-soldermask-silver.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/minimum-text-height-and-thickness.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/minimum-through-hole.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/minimum-track-width.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/minimum-uvia-diameter.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/minimum-uvia-hole.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/minimum-via-diameter.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/minimum_thermal_relief_spoke_count.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/permitted-layers.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/routing-diff-pair.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/routing-width.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/silk-to-soldermask-clearance.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/silk_clearance.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/soldermask-expansion.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/solderpaste-expansion.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/via-style.svg create mode 100644 resources/bitmaps_png/sources/light/constraints/vias-under-smd.svg diff --git a/common/bitmap_info.cpp b/common/bitmap_info.cpp index df8fe83299..42173d3867 100644 --- a/common/bitmap_info.cpp +++ b/common/bitmap_info.cpp @@ -5023,5 +5023,79 @@ void BuildBitmapInfo( std::unordered_map>& aBi aBitmapInfoCache[BITMAPS::stroke_none].emplace_back( BITMAPS::stroke_none, wxT( "stroke_none_dark.png" ), -1, wxT( "dark" ) ); aBitmapInfoCache[BITMAPS::twistedpair].emplace_back( BITMAPS::twistedpair, wxT( "twistedpair_dark.png" ), -1, wxT( "dark" ) ); aBitmapInfoCache[BITMAPS::viacalc].emplace_back( BITMAPS::viacalc, wxT( "viacalc_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_absolute_length_2].emplace_back( BITMAPS::constraint_absolute_length_2, wxT( "constraint_absolute_length_2.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_allowed_orientation].emplace_back( BITMAPS::constraint_allowed_orientation, wxT( "constraint_allowed_orientation.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_basic_clearance].emplace_back( BITMAPS::constraint_basic_clearance, wxT( "constraint_basic_clearance.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_board_outline_clearance].emplace_back( BITMAPS::constraint_board_outline_clearance, wxT( "constraint_board_outline_clearance.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_clearance].emplace_back( BITMAPS::constraint_clearance, wxT( "constraint_clearance.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_copper_to_edge_clearance].emplace_back( BITMAPS::constraint_copper_to_edge_clearance, wxT( "constraint_copper_to_edge_clearance.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_copper_to_hole_clearance].emplace_back( BITMAPS::constraint_copper_to_hole_clearance, wxT( "constraint_copper_to_hole_clearance.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_creepage_distance].emplace_back( BITMAPS::constraint_creepage_distance, wxT( "constraint_creepage_distance.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_hole_size].emplace_back( BITMAPS::constraint_hole_size, wxT( "constraint_hole_size.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_hole_to_hole_clearance].emplace_back( BITMAPS::constraint_hole_to_hole_clearance, wxT( "constraint_hole_to_hole_clearance.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_hole_to_hole_distance].emplace_back( BITMAPS::constraint_hole_to_hole_distance, wxT( "constraint_hole_to_hole_distance.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_length].emplace_back( BITMAPS::constraint_length, wxT( "constraint_length.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_matched_length_diff_pair].emplace_back( BITMAPS::constraint_matched_length_diff_pair, wxT( "constraint_matched_length_diff_pair.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_maximum_allowed_deviation].emplace_back( BITMAPS::constraint_maximum_allowed_deviation, wxT( "constraint_maximum_allowed_deviation.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_maximum_via_count].emplace_back( BITMAPS::constraint_maximum_via_count, wxT( "constraint_maximum_via_count.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_angular_ring].emplace_back( BITMAPS::constraint_minimum_angular_ring, wxT( "constraint_minimum_angular_ring.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_annular_width].emplace_back( BITMAPS::constraint_minimum_annular_width, wxT( "constraint_minimum_annular_width.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_clearance].emplace_back( BITMAPS::constraint_minimum_clearance, wxT( "constraint_minimum_clearance.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_connection_width].emplace_back( BITMAPS::constraint_minimum_connection_width, wxT( "constraint_minimum_connection_width.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_item_clearance].emplace_back( BITMAPS::constraint_minimum_item_clearance, wxT( "constraint_minimum_item_clearance.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_soldermask_silver].emplace_back( BITMAPS::constraint_minimum_soldermask_silver, wxT( "constraint_minimum_soldermask_silver.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_text_height_and_thickness].emplace_back( BITMAPS::constraint_minimum_text_height_and_thickness, wxT( "constraint_minimum_text_height_and_thickness.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_thermal_relief_spoke_count].emplace_back( BITMAPS::constraint_minimum_thermal_relief_spoke_count, wxT( "constraint_minimum_thermal_relief_spoke_count.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_through_hole].emplace_back( BITMAPS::constraint_minimum_through_hole, wxT( "constraint_minimum_through_hole.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_track_width].emplace_back( BITMAPS::constraint_minimum_track_width, wxT( "constraint_minimum_track_width.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_uvia_diameter].emplace_back( BITMAPS::constraint_minimum_uvia_diameter, wxT( "constraint_minimum_uvia_diameter.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_uvia_hole].emplace_back( BITMAPS::constraint_minimum_uvia_hole, wxT( "constraint_minimum_uvia_hole.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_via_diameter].emplace_back( BITMAPS::constraint_minimum_via_diameter, wxT( "constraint_minimum_via_diameter.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_permitted_layers].emplace_back( BITMAPS::constraint_permitted_layers, wxT( "constraint_permitted_layers.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_routing_diff_pair].emplace_back( BITMAPS::constraint_routing_diff_pair, wxT( "constraint_routing_diff_pair.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_routing_width].emplace_back( BITMAPS::constraint_routing_width, wxT( "constraint_routing_width.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_silk_clearance].emplace_back( BITMAPS::constraint_silk_clearance, wxT( "constraint_silk_clearance.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_silk_to_soldermask_clearance].emplace_back( BITMAPS::constraint_silk_to_soldermask_clearance, wxT( "constraint_silk_to_soldermask_clearance.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_soldermask_expansion].emplace_back( BITMAPS::constraint_soldermask_expansion, wxT( "constraint_soldermask_expansion.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_solderpaste_expansion].emplace_back( BITMAPS::constraint_solderpaste_expansion, wxT( "constraint_solderpaste_expansion.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_via_style].emplace_back( BITMAPS::constraint_via_style, wxT( "constraint_via_style.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_vias_under_smd].emplace_back( BITMAPS::constraint_vias_under_smd, wxT( "constraint_vias_under_smd.png" ), -1, wxT( "light" ) ); + aBitmapInfoCache[BITMAPS::constraint_absolute_length_2].emplace_back( BITMAPS::constraint_absolute_length_2, wxT( "constraint_absolute_length_2_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_allowed_orientation].emplace_back( BITMAPS::constraint_allowed_orientation, wxT( "constraint_allowed_orientation_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_basic_clearance].emplace_back( BITMAPS::constraint_basic_clearance, wxT( "constraint_basic_clearance_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_board_outline_clearance].emplace_back( BITMAPS::constraint_board_outline_clearance, wxT( "constraint_board_outline_clearance_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_clearance].emplace_back( BITMAPS::constraint_clearance, wxT( "constraint_clearance_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_copper_to_edge_clearance].emplace_back( BITMAPS::constraint_copper_to_edge_clearance, wxT( "constraint_copper_to_edge_clearance_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_copper_to_hole_clearance].emplace_back( BITMAPS::constraint_copper_to_hole_clearance, wxT( "constraint_copper_to_hole_clearance_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_creepage_distance].emplace_back( BITMAPS::constraint_creepage_distance, wxT( "constraint_creepage_distance_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_hole_size].emplace_back( BITMAPS::constraint_hole_size, wxT( "constraint_hole_size_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_hole_to_hole_clearance].emplace_back( BITMAPS::constraint_hole_to_hole_clearance, wxT( "constraint_hole_to_hole_clearance_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_hole_to_hole_distance].emplace_back( BITMAPS::constraint_hole_to_hole_distance, wxT( "constraint_hole_to_hole_distance_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_length].emplace_back( BITMAPS::constraint_length, wxT( "constraint_length_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_matched_length_diff_pair].emplace_back( BITMAPS::constraint_matched_length_diff_pair, wxT( "constraint_matched_length_diff_pair_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_maximum_allowed_deviation].emplace_back( BITMAPS::constraint_maximum_allowed_deviation, wxT( "constraint_maximum_allowed_deviation_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_maximum_via_count].emplace_back( BITMAPS::constraint_maximum_via_count, wxT( "constraint_maximum_via_count_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_angular_ring].emplace_back( BITMAPS::constraint_minimum_angular_ring, wxT( "constraint_minimum_angular_ring_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_annular_width].emplace_back( BITMAPS::constraint_minimum_annular_width, wxT( "constraint_minimum_annular_width_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_clearance].emplace_back( BITMAPS::constraint_minimum_clearance, wxT( "constraint_minimum_clearance_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_connection_width].emplace_back( BITMAPS::constraint_minimum_connection_width, wxT( "constraint_minimum_connection_width_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_item_clearance].emplace_back( BITMAPS::constraint_minimum_item_clearance, wxT( "constraint_minimum_item_clearance_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_soldermask_silver].emplace_back( BITMAPS::constraint_minimum_soldermask_silver, wxT( "constraint_minimum_soldermask_silver_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_text_height_and_thickness].emplace_back( BITMAPS::constraint_minimum_text_height_and_thickness, wxT( "constraint_minimum_text_height_and_thickness_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_thermal_relief_spoke_count].emplace_back( BITMAPS::constraint_minimum_thermal_relief_spoke_count, wxT( "constraint_minimum_thermal_relief_spoke_count_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_through_hole].emplace_back( BITMAPS::constraint_minimum_through_hole, wxT( "constraint_minimum_through_hole_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_track_width].emplace_back( BITMAPS::constraint_minimum_track_width, wxT( "constraint_minimum_track_width_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_uvia_diameter].emplace_back( BITMAPS::constraint_minimum_uvia_diameter, wxT( "constraint_minimum_uvia_diameter_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_uvia_hole].emplace_back( BITMAPS::constraint_minimum_uvia_hole, wxT( "constraint_minimum_uvia_hole_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_minimum_via_diameter].emplace_back( BITMAPS::constraint_minimum_via_diameter, wxT( "constraint_minimum_via_diameter_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_permitted_layers].emplace_back( BITMAPS::constraint_permitted_layers, wxT( "constraint_permitted_layers_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_routing_diff_pair].emplace_back( BITMAPS::constraint_routing_diff_pair, wxT( "constraint_routing_diff_pair_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_routing_width].emplace_back( BITMAPS::constraint_routing_width, wxT( "constraint_routing_width_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_silk_clearance].emplace_back( BITMAPS::constraint_silk_clearance, wxT( "constraint_silk_clearance_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_silk_to_soldermask_clearance].emplace_back( BITMAPS::constraint_silk_to_soldermask_clearance, wxT( "constraint_silk_to_soldermask_clearance_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_soldermask_expansion].emplace_back( BITMAPS::constraint_soldermask_expansion, wxT( "constraint_soldermask_expansion_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_solderpaste_expansion].emplace_back( BITMAPS::constraint_solderpaste_expansion, wxT( "constraint_solderpaste_expansion_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_via_style].emplace_back( BITMAPS::constraint_via_style, wxT( "constraint_via_style_dark.png" ), -1, wxT( "dark" ) ); + aBitmapInfoCache[BITMAPS::constraint_vias_under_smd].emplace_back( BITMAPS::constraint_vias_under_smd, wxT( "constraint_vias_under_smd_dark.png" ), -1, wxT( "dark" ) ); }; diff --git a/include/bitmaps/bitmaps_list.h b/include/bitmaps/bitmaps_list.h index cfc8e9f355..fcd538fdaf 100644 --- a/include/bitmaps/bitmaps_list.h +++ b/include/bitmaps/bitmaps_list.h @@ -693,7 +693,7 @@ enum class BITMAPS : unsigned int zoom_selection, constraint_basic_clearance, - constraint_outline_clearance, + constraint_board_outline_clearance, constraint_minimum_clearance, constraint_net_antenna, constraint_short_circuit, @@ -727,7 +727,10 @@ enum class BITMAPS : unsigned int constraint_matched_length_diff_pair, constraint_routing_diff_pair, constraint_routing_width, + constraint_clearance, + constraint_length, constraint_maximum_via_count, + constraint_silk_clearance, constraint_matched_length_all_traces_in_group, constraint_absolute_length, constraint_absolute_length_2, diff --git a/pcbnew/CMakeLists.txt b/pcbnew/CMakeLists.txt index 34bde75b54..b79694f708 100644 --- a/pcbnew/CMakeLists.txt +++ b/pcbnew/CMakeLists.txt @@ -338,7 +338,19 @@ set( PCBNEW_DRC_SRCS drc/rule_editor/drc_re_permitted_layers_panel.cpp drc/rule_editor/drc_re_allowed_orientation_panel_base.cpp drc/rule_editor/drc_re_allowed_orientation_panel.cpp + drc/rule_editor/drc_re_bitmap_overlay_panel.cpp drc/rule_editor/drc_re_object_selector_panel.cpp + drc/rule_editor/drc_re_overlay_field.cpp + drc/rule_editor/drc_re_routing_width_overlay_panel.cpp + drc/rule_editor/drc_re_rtg_diff_pair_overlay_panel.cpp + drc/rule_editor/drc_re_min_txt_ht_th_overlay_panel.cpp + drc/rule_editor/drc_re_abs_length_two_overlay_panel.cpp + drc/rule_editor/drc_re_via_style_overlay_panel.cpp + drc/rule_editor/drc_re_numeric_input_overlay_panel.cpp + drc/rule_editor/drc_re_bool_input_overlay_panel.cpp + drc/rule_editor/drc_re_permitted_layers_overlay_panel.cpp + drc/rule_editor/drc_re_allowed_orientation_overlay_panel.cpp + drc/rule_editor/drc_re_overlay_panel_factory.cpp drc/rule_editor/drc_re_condition_row_panel.cpp drc/rule_editor/drc_re_condition_group_panel.cpp drc/rule_editor/drc_re_custom_rule_panel.cpp diff --git a/pcbnew/drc/rule_editor/drc_re_abs_length_two_constraint_data.h b/pcbnew/drc/rule_editor/drc_re_abs_length_two_constraint_data.h index 5e7f88ce8f..c299591b0c 100644 --- a/pcbnew/drc/rule_editor/drc_re_abs_length_two_constraint_data.h +++ b/pcbnew/drc/rule_editor/drc_re_abs_length_two_constraint_data.h @@ -52,6 +52,19 @@ public: virtual ~DRC_RE_ABSOLUTE_LENGTH_TWO_CONSTRAINT_DATA() = default; + BITMAPS GetOverlayBitmap() const override { return BITMAPS::constraint_absolute_length_2; } + + std::vector GetFieldPositions() const override + { + // Positions measured from constraint_absolute_lenght_2.png (~340x130) + // Format: { xStart, xEnd, yTop, tabOrder } + return { + { 35, 95, 30, 1 }, // min_length (left arrow) + { 165, 225, 85, 2 }, // opt_length (bottom center arrow) + { 290, 350, 30, 3 }, // max_length (right arrow) + }; + } + double GetMinimumLength() const { return m_minLength; } void SetMinimumLength( double aLength ) { m_minLength = aLength; } diff --git a/pcbnew/drc/rule_editor/drc_re_abs_length_two_overlay_panel.cpp b/pcbnew/drc/rule_editor/drc_re_abs_length_two_overlay_panel.cpp new file mode 100644 index 0000000000..3f6c0dc9bd --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_abs_length_two_overlay_panel.cpp @@ -0,0 +1,117 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "drc_re_abs_length_two_overlay_panel.h" +#include "drc_re_abs_length_two_constraint_data.h" +#include "drc_rule_editor_utils.h" + +#include +#include + +#include + + +DRC_RE_ABS_LENGTH_TWO_OVERLAY_PANEL::DRC_RE_ABS_LENGTH_TWO_OVERLAY_PANEL( + wxWindow* aParent, DRC_RE_ABSOLUTE_LENGTH_TWO_CONSTRAINT_DATA* aData, EDA_UNITS aUnits ) : + DRC_RE_BITMAP_OVERLAY_PANEL( aParent ), + m_data( aData ), + m_unitsProvider( pcbIUScale, aUnits ) +{ + SetBackgroundBitmap( BITMAPS::constraint_absolute_length_2 ); + + std::vector positions = m_data->GetFieldPositions(); + + m_minLengthBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "min_length" ), positions[0], m_minLengthBinder.get() ); + + m_optLengthBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "opt_length" ), positions[1], m_optLengthBinder.get() ); + + m_maxLengthBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "max_length" ), positions[2], m_maxLengthBinder.get() ); + + PositionFields(); + TransferDataToWindow(); +} + + +bool DRC_RE_ABS_LENGTH_TWO_OVERLAY_PANEL::TransferDataToWindow() +{ + if( !m_data ) + return false; + + m_minLengthBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetMinimumLength() ) ); + m_optLengthBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetOptimumLength() ) ); + m_maxLengthBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetMaximumLength() ) ); + + return true; +} + + +bool DRC_RE_ABS_LENGTH_TWO_OVERLAY_PANEL::TransferDataFromWindow() +{ + if( !m_data ) + return false; + + m_data->SetMinimumLength( pcbIUScale.IUTomm( m_minLengthBinder->GetDoubleValue() ) ); + m_data->SetOptimumLength( pcbIUScale.IUTomm( m_optLengthBinder->GetDoubleValue() ) ); + m_data->SetMaximumLength( pcbIUScale.IUTomm( m_maxLengthBinder->GetDoubleValue() ) ); + + return true; +} + + +bool DRC_RE_ABS_LENGTH_TWO_OVERLAY_PANEL::ValidateInputs( int* aErrorCount, + std::string* aValidationMessage ) +{ + TransferDataFromWindow(); + + VALIDATION_RESULT result = m_data->Validate(); + + if( !result.isValid ) + { + *aErrorCount = result.errors.size(); + + for( size_t i = 0; i < result.errors.size(); i++ ) + *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage( i + 1, result.errors[i] ); + + return false; + } + + return true; +} + + +wxString DRC_RE_ABS_LENGTH_TWO_OVERLAY_PANEL::GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) +{ + if( !m_data ) + return wxEmptyString; + + return m_data->GenerateRule( aContext ); +} diff --git a/pcbnew/drc/rule_editor/drc_re_abs_length_two_overlay_panel.h b/pcbnew/drc/rule_editor/drc_re_abs_length_two_overlay_panel.h new file mode 100644 index 0000000000..57e6970149 --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_abs_length_two_overlay_panel.h @@ -0,0 +1,68 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef DRC_RE_ABS_LENGTH_TWO_OVERLAY_PANEL_H +#define DRC_RE_ABS_LENGTH_TWO_OVERLAY_PANEL_H + +#include + +#include + +#include "drc_re_bitmap_overlay_panel.h" + +enum class EDA_UNITS; + +class DRC_RE_ABSOLUTE_LENGTH_TWO_CONSTRAINT_DATA; +class UNIT_BINDER; + + +/** + * Overlay panel for absolute length constraints showing min, opt, and max length fields + * positioned over a diagram. + */ +class DRC_RE_ABS_LENGTH_TWO_OVERLAY_PANEL : public DRC_RE_BITMAP_OVERLAY_PANEL +{ +public: + DRC_RE_ABS_LENGTH_TWO_OVERLAY_PANEL( wxWindow* aParent, + DRC_RE_ABSOLUTE_LENGTH_TWO_CONSTRAINT_DATA* aData, + EDA_UNITS aUnits ); + + ~DRC_RE_ABS_LENGTH_TWO_OVERLAY_PANEL() override = default; + + bool TransferDataToWindow() override; + bool TransferDataFromWindow() override; + + bool ValidateInputs( int* aErrorCount, std::string* aValidationMessage ) override; + wxString GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) override; + +private: + DRC_RE_ABSOLUTE_LENGTH_TWO_CONSTRAINT_DATA* m_data; + + UNITS_PROVIDER m_unitsProvider; + + std::unique_ptr m_minLengthBinder; + std::unique_ptr m_optLengthBinder; + std::unique_ptr m_maxLengthBinder; +}; + +#endif // DRC_RE_ABS_LENGTH_TWO_OVERLAY_PANEL_H diff --git a/pcbnew/drc/rule_editor/drc_re_allowed_orientation_constraint_data.h b/pcbnew/drc/rule_editor/drc_re_allowed_orientation_constraint_data.h index 9a2bf10606..b064d0d87e 100644 --- a/pcbnew/drc/rule_editor/drc_re_allowed_orientation_constraint_data.h +++ b/pcbnew/drc/rule_editor/drc_re_allowed_orientation_constraint_data.h @@ -52,6 +52,22 @@ public: virtual ~DRC_RE_ALLOWED_ORIENTATION_CONSTRAINT_DATA() = default; + BITMAPS GetOverlayBitmap() const override { return BITMAPS::constraint_allowed_orientation; } + + std::vector GetFieldPositions() const override + { + // Positions measured from constraint_allowed_orientation.png (~280x180) + // Format: { xStart, xEnd, yTop, tabOrder } + // Checkboxes stacked vertically on the right side + return { + { 230, 270, 20, 1 }, // 0 degrees checkbox + { 230, 270, 50, 2 }, // 90 degrees checkbox + { 230, 270, 80, 3 }, // 180 degrees checkbox + { 230, 270, 110, 4 }, // 270 degrees checkbox + { 230, 270, 140, 5 }, // all degrees checkbox + }; + } + VALIDATION_RESULT Validate() const override { VALIDATION_RESULT result; diff --git a/pcbnew/drc/rule_editor/drc_re_allowed_orientation_overlay_panel.cpp b/pcbnew/drc/rule_editor/drc_re_allowed_orientation_overlay_panel.cpp new file mode 100644 index 0000000000..ed6527dc15 --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_allowed_orientation_overlay_panel.cpp @@ -0,0 +1,128 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "drc_re_allowed_orientation_overlay_panel.h" +#include "drc_re_allowed_orientation_constraint_data.h" +#include "drc_rule_editor_utils.h" + +#include + + +DRC_RE_ALLOWED_ORIENTATION_OVERLAY_PANEL::DRC_RE_ALLOWED_ORIENTATION_OVERLAY_PANEL( + wxWindow* aParent, DRC_RE_ALLOWED_ORIENTATION_CONSTRAINT_DATA* aData ) : + DRC_RE_BITMAP_OVERLAY_PANEL( aParent ), + m_data( aData ), + m_zeroDegreesCheckbox( nullptr ), + m_ninetyDegreesCheckbox( nullptr ), + m_oneEightyDegreesCheckbox( nullptr ), + m_twoSeventyDegreesCheckbox( nullptr ), + m_allDegreesCheckbox( nullptr ) +{ + SetBackgroundBitmap( m_data->GetOverlayBitmap() ); + + std::vector positions = m_data->GetFieldPositions(); + + DRC_RE_OVERLAY_FIELD* field = AddCheckbox( wxS( "zero_degrees" ), positions[0] ); + m_zeroDegreesCheckbox = static_cast( field->GetControl() ); + + field = AddCheckbox( wxS( "ninety_degrees" ), positions[1] ); + m_ninetyDegreesCheckbox = static_cast( field->GetControl() ); + + field = AddCheckbox( wxS( "one_eighty_degrees" ), positions[2] ); + m_oneEightyDegreesCheckbox = static_cast( field->GetControl() ); + + field = AddCheckbox( wxS( "two_seventy_degrees" ), positions[3] ); + m_twoSeventyDegreesCheckbox = static_cast( field->GetControl() ); + + field = AddCheckbox( wxS( "all_degrees" ), positions[4] ); + m_allDegreesCheckbox = static_cast( field->GetControl() ); + + PositionFields(); + TransferDataToWindow(); +} + + +bool DRC_RE_ALLOWED_ORIENTATION_OVERLAY_PANEL::TransferDataToWindow() +{ + if( !m_data || !m_zeroDegreesCheckbox || !m_ninetyDegreesCheckbox || !m_oneEightyDegreesCheckbox + || !m_twoSeventyDegreesCheckbox || !m_allDegreesCheckbox ) + { + return false; + } + + m_zeroDegreesCheckbox->SetValue( m_data->GetIsZeroDegreesAllowed() ); + m_ninetyDegreesCheckbox->SetValue( m_data->GetIsNinetyDegreesAllowed() ); + m_oneEightyDegreesCheckbox->SetValue( m_data->GetIsOneEightyDegreesAllowed() ); + m_twoSeventyDegreesCheckbox->SetValue( m_data->GetIsTwoSeventyDegreesAllowed() ); + m_allDegreesCheckbox->SetValue( m_data->GetIsAllDegreesAllowed() ); + + return true; +} + + +bool DRC_RE_ALLOWED_ORIENTATION_OVERLAY_PANEL::TransferDataFromWindow() +{ + if( !m_data || !m_zeroDegreesCheckbox || !m_ninetyDegreesCheckbox || !m_oneEightyDegreesCheckbox + || !m_twoSeventyDegreesCheckbox || !m_allDegreesCheckbox ) + { + return false; + } + + m_data->SetIsZeroDegreesAllowed( m_zeroDegreesCheckbox->GetValue() ); + m_data->SetIsNinetyDegreesAllowed( m_ninetyDegreesCheckbox->GetValue() ); + m_data->SetIsOneEightyDegreesAllowed( m_oneEightyDegreesCheckbox->GetValue() ); + m_data->SetIsTwoSeventyDegreesAllowed( m_twoSeventyDegreesCheckbox->GetValue() ); + m_data->SetIsAllDegreesAllowed( m_allDegreesCheckbox->GetValue() ); + + return true; +} + + +bool DRC_RE_ALLOWED_ORIENTATION_OVERLAY_PANEL::ValidateInputs( int* aErrorCount, + std::string* aValidationMessage ) +{ + TransferDataFromWindow(); + + VALIDATION_RESULT result = m_data->Validate(); + + if( !result.isValid ) + { + *aErrorCount = result.errors.size(); + + for( size_t i = 0; i < result.errors.size(); i++ ) + *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage( i + 1, result.errors[i] ); + + return false; + } + + return true; +} + + +wxString DRC_RE_ALLOWED_ORIENTATION_OVERLAY_PANEL::GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) +{ + if( !m_data ) + return wxEmptyString; + + return m_data->GenerateRule( aContext ); +} diff --git a/pcbnew/drc/rule_editor/drc_re_allowed_orientation_overlay_panel.h b/pcbnew/drc/rule_editor/drc_re_allowed_orientation_overlay_panel.h new file mode 100644 index 0000000000..739841e9f1 --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_allowed_orientation_overlay_panel.h @@ -0,0 +1,61 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef DRC_RE_ALLOWED_ORIENTATION_OVERLAY_PANEL_H +#define DRC_RE_ALLOWED_ORIENTATION_OVERLAY_PANEL_H + +#include "drc_re_bitmap_overlay_panel.h" + +class DRC_RE_ALLOWED_ORIENTATION_CONSTRAINT_DATA; +class wxCheckBox; + + +/** + * Overlay panel for allowed orientation constraints showing checkboxes + * for each orientation angle positioned over a diagram. + */ +class DRC_RE_ALLOWED_ORIENTATION_OVERLAY_PANEL : public DRC_RE_BITMAP_OVERLAY_PANEL +{ +public: + DRC_RE_ALLOWED_ORIENTATION_OVERLAY_PANEL( wxWindow* aParent, + DRC_RE_ALLOWED_ORIENTATION_CONSTRAINT_DATA* aData ); + + ~DRC_RE_ALLOWED_ORIENTATION_OVERLAY_PANEL() override = default; + + bool TransferDataToWindow() override; + bool TransferDataFromWindow() override; + + bool ValidateInputs( int* aErrorCount, std::string* aValidationMessage ) override; + wxString GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) override; + +private: + DRC_RE_ALLOWED_ORIENTATION_CONSTRAINT_DATA* m_data; + + wxCheckBox* m_zeroDegreesCheckbox; + wxCheckBox* m_ninetyDegreesCheckbox; + wxCheckBox* m_oneEightyDegreesCheckbox; + wxCheckBox* m_twoSeventyDegreesCheckbox; + wxCheckBox* m_allDegreesCheckbox; +}; + +#endif // DRC_RE_ALLOWED_ORIENTATION_OVERLAY_PANEL_H diff --git a/pcbnew/drc/rule_editor/drc_re_base_constraint_data.h b/pcbnew/drc/rule_editor/drc_re_base_constraint_data.h index 1348f9e1d4..05f872c5f4 100644 --- a/pcbnew/drc/rule_editor/drc_re_base_constraint_data.h +++ b/pcbnew/drc/rule_editor/drc_re_base_constraint_data.h @@ -24,11 +24,15 @@ #ifndef DRC_RE_BASE_CONSTRAINT_DATA_H_ #define DRC_RE_BASE_CONSTRAINT_DATA_H_ +#include #include +#include "drc_re_overlay_types.h" #include "drc_rule_editor_enums.h" #include #include +#include + class DRC_RE_BASE_CONSTRAINT_DATA : public RULE_EDITOR_DATA_BASE { @@ -52,6 +56,23 @@ public: virtual wxString GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) { return wxEmptyString; } + /** + * Returns the bitmap to use for the overlay panel background. + * Override in derived classes to provide constraint-specific artwork. + * + * @return BITMAPS enum value for the overlay bitmap, or BITMAPS::INVALID_BITMAP if none. + */ + virtual BITMAPS GetOverlayBitmap() const { return BITMAPS::INVALID_BITMAP; } + + /** + * Returns the field positions for controls overlaid on the constraint bitmap. + * Override in derived classes to specify where input fields should be placed. + * Each position includes X range, Y coordinate, and tab order for navigation. + * + * @return Vector of field position specifications, empty if no overlay fields. + */ + virtual std::vector GetFieldPositions() const { return {}; } + /** * Returns just the constraint clauses without the rule wrapper. * Used for merging multiple constraint panels into a single rule. diff --git a/pcbnew/drc/rule_editor/drc_re_bitmap_overlay_panel.cpp b/pcbnew/drc/rule_editor/drc_re_bitmap_overlay_panel.cpp new file mode 100644 index 0000000000..d86e787e7a --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_bitmap_overlay_panel.cpp @@ -0,0 +1,299 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "drc_re_bitmap_overlay_panel.h" +#include "drc_re_overlay_field.h" + +#include + +#include +#include +#include +#include +#include + + +DRC_RE_BITMAP_OVERLAY_PANEL::DRC_RE_BITMAP_OVERLAY_PANEL( wxWindow* aParent, wxWindowID aId ) : + wxPanel(), + m_bitmapId( BITMAPS::INVALID_BITMAP ), + m_baseBitmapSize( 0, 0 ) +{ + // Must set background style BEFORE creating the window + SetBackgroundStyle( wxBG_STYLE_PAINT ); + Create( aParent, aId ); + + Bind( wxEVT_PAINT, &DRC_RE_BITMAP_OVERLAY_PANEL::OnPaint, this ); + Bind( wxEVT_DPI_CHANGED, &DRC_RE_BITMAP_OVERLAY_PANEL::OnDPIChanged, this ); + Bind( wxEVT_SYS_COLOUR_CHANGED, &DRC_RE_BITMAP_OVERLAY_PANEL::OnThemeChange, this ); +} + + +DRC_RE_BITMAP_OVERLAY_PANEL::~DRC_RE_BITMAP_OVERLAY_PANEL() +{ +} + + +void DRC_RE_BITMAP_OVERLAY_PANEL::OnPaint( wxPaintEvent& aEvent ) +{ + wxPaintDC dc( this ); + + if( !m_bitmap.IsOk() ) + return; + + dc.DrawBitmap( m_bitmap, 0, 0, true ); +} + + +void DRC_RE_BITMAP_OVERLAY_PANEL::OnDPIChanged( wxDPIChangedEvent& aEvent ) +{ + LoadBitmap(); + PositionFields(); + Refresh(); + aEvent.Skip(); +} + + +void DRC_RE_BITMAP_OVERLAY_PANEL::OnThemeChange( wxSysColourChangedEvent& aEvent ) +{ + LoadBitmap(); + Refresh(); + aEvent.Skip(); +} + + +void DRC_RE_BITMAP_OVERLAY_PANEL::OnFieldFocus( wxFocusEvent& aEvent ) +{ + // Platform handles focus ring automatically. + // Could add custom highlighting here if needed. + aEvent.Skip(); +} + + +void DRC_RE_BITMAP_OVERLAY_PANEL::OnFieldBlur( wxFocusEvent& aEvent ) +{ + // Platform handles focus ring automatically. + aEvent.Skip(); +} + + +void DRC_RE_BITMAP_OVERLAY_PANEL::SetupFieldStyling( wxControl* aControl ) +{ + if( !aControl ) + return; + + // Bind focus events to track active field + aControl->Bind( wxEVT_SET_FOCUS, &DRC_RE_BITMAP_OVERLAY_PANEL::OnFieldFocus, this ); + aControl->Bind( wxEVT_KILL_FOCUS, &DRC_RE_BITMAP_OVERLAY_PANEL::OnFieldBlur, this ); +} + + +double DRC_RE_BITMAP_OVERLAY_PANEL::GetScaleFactor() const +{ + double scale = GetContentScaleFactor(); + + // Round to nearest supported bitmap resolution (1.0, 1.5, or 2.0) + if( scale < 1.25 ) + return 1.0; + else if( scale < 1.75 ) + return 1.5; + else + return 2.0; +} + + +wxPoint DRC_RE_BITMAP_OVERLAY_PANEL::ScalePosition( int aX, int aY ) const +{ + double scale = GetScaleFactor(); + return wxPoint( static_cast( aX * scale ), static_cast( aY * scale ) ); +} + + +wxSize DRC_RE_BITMAP_OVERLAY_PANEL::ScaleSize( int aWidth, int aHeight ) const +{ + double scale = GetScaleFactor(); + return wxSize( static_cast( aWidth * scale ), static_cast( aHeight * scale ) ); +} + + +void DRC_RE_BITMAP_OVERLAY_PANEL::LoadBitmap() +{ + if( m_bitmapId == BITMAPS::INVALID_BITMAP ) + return; + + wxBitmapBundle bundle = KiBitmapBundle( m_bitmapId ); + + m_bitmap = bundle.GetBitmapFor( this ); + m_baseBitmapSize = bundle.GetDefaultSize(); + + Refresh(); +} + + +void DRC_RE_BITMAP_OVERLAY_PANEL::SetBackgroundBitmap( BITMAPS aBitmap ) +{ + m_bitmapId = aBitmap; + LoadBitmap(); + + if( m_bitmap.IsOk() ) + SetMinSize( m_bitmap.GetSize() ); +} + + +void DRC_RE_BITMAP_OVERLAY_PANEL::PositionFields() +{ + for( const auto& field : m_fields ) + { + const DRC_RE_FIELD_POSITION& pos = field->GetPosition(); + wxControl* ctrl = field->GetControl(); + + if( !ctrl ) + continue; + + // Calculate scaled position and size + wxPoint scaledPos = ScalePosition( pos.xStart, pos.yTop ); + int width = pos.xEnd - pos.xStart; + wxSize scaledSize = ScaleSize( width, ctrl->GetBestSize().GetHeight() ); + + // Check bounds + if( m_bitmap.IsOk() ) + { + wxSize bmpSize = m_bitmap.GetSize(); + + if( scaledPos.x + scaledSize.GetWidth() > bmpSize.GetWidth() || + scaledPos.y + scaledSize.GetHeight() > bmpSize.GetHeight() ) + { + wxLogWarning( "Field '%s' position exceeds bitmap bounds", field->GetFieldId() ); + } + } + + ctrl->SetPosition( scaledPos ); + ctrl->SetSize( scaledSize ); + + // Position label if present + if( field->HasLabel() ) + PositionLabel( field.get() ); + } +} + + +void DRC_RE_BITMAP_OVERLAY_PANEL::PositionLabel( DRC_RE_OVERLAY_FIELD* aField ) +{ + wxStaticText* label = aField->GetLabel(); + wxControl* ctrl = aField->GetControl(); + + if( !label || !ctrl ) + return; + + const DRC_RE_FIELD_POSITION& pos = aField->GetPosition(); + wxPoint ctrlPos = ctrl->GetPosition(); + wxSize ctrlSize = ctrl->GetSize(); + wxSize labelSize = label->GetBestSize(); + + wxPoint labelPos; + constexpr int GAP = 4; + + switch( pos.labelPosition ) + { + case LABEL_POSITION::LEFT: + labelPos.x = ctrlPos.x - labelSize.GetWidth() - GAP; + labelPos.y = ctrlPos.y + ( ctrlSize.GetHeight() - labelSize.GetHeight() ) / 2; + break; + + case LABEL_POSITION::RIGHT: + labelPos.x = ctrlPos.x + ctrlSize.GetWidth() + GAP; + labelPos.y = ctrlPos.y + ( ctrlSize.GetHeight() - labelSize.GetHeight() ) / 2; + break; + + case LABEL_POSITION::TOP: + labelPos.x = ctrlPos.x + ( ctrlSize.GetWidth() - labelSize.GetWidth() ) / 2; + labelPos.y = ctrlPos.y - labelSize.GetHeight() - GAP; + break; + + case LABEL_POSITION::BOTTOM: + labelPos.x = ctrlPos.x + ( ctrlSize.GetWidth() - labelSize.GetWidth() ) / 2; + labelPos.y = ctrlPos.y + ctrlSize.GetHeight() + GAP; + break; + + case LABEL_POSITION::NONE: + default: + return; + } + + label->SetPosition( labelPos ); +} + + +bool DRC_RE_BITMAP_OVERLAY_PANEL::TransferDataToWindow() +{ + // Base implementation does nothing; derived classes override to populate fields + return true; +} + + +bool DRC_RE_BITMAP_OVERLAY_PANEL::TransferDataFromWindow() +{ + // Base implementation does nothing; derived classes override to read fields + return true; +} + + +void DRC_RE_BITMAP_OVERLAY_PANEL::ClearFieldErrors() +{ + for( const auto& field : m_fields ) + field->ShowError( false ); +} + + +void DRC_RE_BITMAP_OVERLAY_PANEL::ShowFieldError( const wxString& aFieldId ) +{ + auto it = m_fieldIdMap.find( aFieldId ); + + if( it != m_fieldIdMap.end() ) + it->second->ShowError( true ); +} + + +DRC_RE_OVERLAY_FIELD* DRC_RE_BITMAP_OVERLAY_PANEL::AddCheckbox( const wxString& aId, + const DRC_RE_FIELD_POSITION& aPosition ) +{ + wxCheckBox* checkbox = new wxCheckBox( this, wxID_ANY, wxEmptyString ); + + auto field = std::make_unique( this, aId, checkbox, aPosition ); + DRC_RE_OVERLAY_FIELD* fieldPtr = field.get(); + + SetupFieldStyling( checkbox ); + + wxPoint pos = ScalePosition( aPosition.xStart, aPosition.yTop ); + checkbox->SetPosition( pos ); + + // Create label if specified + fieldPtr->CreateLabel(); + + if( fieldPtr->HasLabel() ) + PositionLabel( fieldPtr ); + + m_fieldIdMap[aId] = fieldPtr; + m_fields.push_back( std::move( field ) ); + + return fieldPtr; +} diff --git a/pcbnew/drc/rule_editor/drc_re_bitmap_overlay_panel.h b/pcbnew/drc/rule_editor/drc_re_bitmap_overlay_panel.h new file mode 100644 index 0000000000..d684a3e83c --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_bitmap_overlay_panel.h @@ -0,0 +1,238 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef DRC_RE_BITMAP_OVERLAY_PANEL_H +#define DRC_RE_BITMAP_OVERLAY_PANEL_H + +#include +#include +#include + +#include +#include + +#include +#include "drc_re_content_panel_base.h" +#include "drc_re_overlay_field.h" +#include "drc_re_overlay_types.h" + +class wxControl; +class wxCheckBox; +class wxPaintEvent; +class wxDPIChangedEvent; +class wxSysColourChangedEvent; +class wxFocusEvent; +class UNIT_BINDER; + + +/** + * Base class for DRC rule editor panels that display input fields overlaid on a bitmap. + * + * This class provides infrastructure for creating constraint editor panels where input fields + * are precisely positioned over explanatory constraint diagrams. The bitmap serves as a visual + * guide showing what each field value represents. + * + * Derived classes should: + * - Call SetBackgroundBitmap() in their constructor to set the diagram + * - Create fields using AddField(), AddFieldWithUnits(), or AddCheckbox() + * - Override TransferDataToWindow/FromWindow to populate/read field values + */ +class DRC_RE_BITMAP_OVERLAY_PANEL : public wxPanel, + public DRC_RULE_EDITOR_CONTENT_PANEL_BASE +{ +public: + DRC_RE_BITMAP_OVERLAY_PANEL( wxWindow* aParent, wxWindowID aId = wxID_ANY ); + + virtual ~DRC_RE_BITMAP_OVERLAY_PANEL(); + + /** + * Set the background bitmap for this panel. + * + * @param aBitmap The BITMAPS enum value identifying the constraint diagram. + */ + void SetBackgroundBitmap( BITMAPS aBitmap ); + + bool TransferDataToWindow() override; + bool TransferDataFromWindow() override; + + /** + * Clear error indicators from all fields. + */ + void ClearFieldErrors(); + + /** + * Show an error indicator on the specified field. + * + * @param aFieldId The string identifier of the field to highlight. + */ + void ShowFieldError( const wxString& aFieldId ); + +protected: + /** + * Create and position a field control on the bitmap overlay. + * + * @tparam T The wxWindow-derived control type to create. + * @param aId String identifier for this field (used for error display and lookup). + * @param aPosition Position specification in 1x bitmap coordinates. + * @return Pointer to the created field wrapper. + */ + template + DRC_RE_OVERLAY_FIELD* AddField( const wxString& aId, const DRC_RE_FIELD_POSITION& aPosition ); + + /** + * Create and position a field control with unit binding. + * + * @tparam T The wxWindow-derived control type to create. + * @param aId String identifier for this field. + * @param aPosition Position specification in 1x bitmap coordinates. + * @param aUnitBinder UNIT_BINDER to associate with this field for unit conversion. + * @return Pointer to the created field wrapper. + */ + template + DRC_RE_OVERLAY_FIELD* AddFieldWithUnits( const wxString& aId, + const DRC_RE_FIELD_POSITION& aPosition, + UNIT_BINDER* aUnitBinder ); + + /** + * Create and position a checkbox control on the bitmap overlay. + * + * @param aId String identifier for this checkbox. + * @param aPosition Position specification in 1x bitmap coordinates. + * @return Pointer to the created field wrapper. + */ + DRC_RE_OVERLAY_FIELD* AddCheckbox( const wxString& aId, const DRC_RE_FIELD_POSITION& aPosition ); + + /** + * Load the appropriate bitmap variant for the current theme and DPI. + */ + void LoadBitmap(); + + /** + * Position all fields based on the current scale factor. + */ + void PositionFields(); + + /** + * Get the current DPI scale factor. + * + * @return Scale factor (1.0, 1.5, or 2.0). + */ + double GetScaleFactor() const; + + /** + * Scale pixel coordinates from 1x bitmap space to current display space. + * + * @param aX X coordinate in 1x bitmap pixels. + * @param aY Y coordinate in 1x bitmap pixels. + * @return Scaled position as wxPoint. + */ + wxPoint ScalePosition( int aX, int aY ) const; + + /** + * Scale pixel dimensions from 1x bitmap space to current display space. + * + * @param aWidth Width in 1x bitmap pixels. + * @param aHeight Height in 1x bitmap pixels. + * @return Scaled size as wxSize. + */ + wxSize ScaleSize( int aWidth, int aHeight ) const; + + /** + * Apply transparent styling to a field control. + * + * @param aControl The control to style. + */ + void SetupFieldStyling( wxControl* aControl ); + +private: + void OnPaint( wxPaintEvent& aEvent ); + void OnDPIChanged( wxDPIChangedEvent& aEvent ); + void OnThemeChange( wxSysColourChangedEvent& aEvent ); + void OnFieldFocus( wxFocusEvent& aEvent ); + void OnFieldBlur( wxFocusEvent& aEvent ); + + /** + * Position a label relative to its field control based on the label position setting. + * + * @param aField The overlay field containing the label to position. + */ + void PositionLabel( DRC_RE_OVERLAY_FIELD* aField ); + + wxBitmap m_bitmap; ///< Current background bitmap + BITMAPS m_bitmapId; ///< BITMAPS enum value + wxSize m_baseBitmapSize; ///< Bitmap size at 1x scale + std::vector> m_fields; ///< All overlay fields + std::map m_fieldIdMap; ///< Field ID to field lookup +}; + + +template +DRC_RE_OVERLAY_FIELD* DRC_RE_BITMAP_OVERLAY_PANEL::AddField( const wxString& aId, + const DRC_RE_FIELD_POSITION& aPosition ) +{ + // Create the control + T* control = new T( this, wxID_ANY ); + + // Create the overlay field wrapper + auto field = std::make_unique( this, aId, control, aPosition ); + DRC_RE_OVERLAY_FIELD* fieldPtr = field.get(); + + // Set up styling + SetupFieldStyling( control ); + + // Position the field + wxPoint pos = ScalePosition( aPosition.xStart, aPosition.yTop ); + int width = aPosition.xEnd - aPosition.xStart; + wxSize size = ScaleSize( width, control->GetBestSize().GetHeight() ); + control->SetPosition( pos ); + control->SetSize( size ); + + // Create label if specified + fieldPtr->CreateLabel(); + + if( fieldPtr->HasLabel() ) + PositionLabel( fieldPtr ); + + // Store in collections + m_fieldIdMap[aId] = fieldPtr; + m_fields.push_back( std::move( field ) ); + + return fieldPtr; +} + + +template +DRC_RE_OVERLAY_FIELD* DRC_RE_BITMAP_OVERLAY_PANEL::AddFieldWithUnits( const wxString& aId, + const DRC_RE_FIELD_POSITION& aPosition, + UNIT_BINDER* aUnitBinder ) +{ + // Create the field using the base AddField method + DRC_RE_OVERLAY_FIELD* field = AddField( aId, aPosition ); + + // Associate the unit binder for value conversion + field->SetUnitBinder( aUnitBinder ); + + return field; +} + +#endif // DRC_RE_BITMAP_OVERLAY_PANEL_H diff --git a/pcbnew/drc/rule_editor/drc_re_bool_input_constraint_data.h b/pcbnew/drc/rule_editor/drc_re_bool_input_constraint_data.h index 78d6fc1d89..944f86242a 100644 --- a/pcbnew/drc/rule_editor/drc_re_bool_input_constraint_data.h +++ b/pcbnew/drc/rule_editor/drc_re_bool_input_constraint_data.h @@ -46,6 +46,17 @@ public: virtual ~DRC_RE_BOOL_INPUT_CONSTRAINT_DATA() = default; + BITMAPS GetOverlayBitmap() const override { return BITMAPS::constraint_vias_under_smd; } + + std::vector GetFieldPositions() const override + { + // Positions measured from constraint_vias_under_SMD.png (~280x160) + // Format: { xStart, xEnd, yTop, tabOrder } + return { + { 20, 40, 130, 1 }, // checkbox (bottom left corner) + }; + } + VALIDATION_RESULT Validate() const override { // Boolean inputs are always valid - any true/false value is acceptable diff --git a/pcbnew/drc/rule_editor/drc_re_bool_input_overlay_panel.cpp b/pcbnew/drc/rule_editor/drc_re_bool_input_overlay_panel.cpp new file mode 100644 index 0000000000..7b996f852f --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_bool_input_overlay_panel.cpp @@ -0,0 +1,98 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "drc_re_bool_input_overlay_panel.h" +#include "drc_re_bool_input_constraint_data.h" +#include "drc_rule_editor_utils.h" + +#include + + +DRC_RE_BOOL_INPUT_OVERLAY_PANEL::DRC_RE_BOOL_INPUT_OVERLAY_PANEL( + wxWindow* aParent, DRC_RE_BOOL_INPUT_CONSTRAINT_DATA* aData ) : + DRC_RE_BITMAP_OVERLAY_PANEL( aParent ), + m_data( aData ), + m_boolInputCheckbox( nullptr ) +{ + SetBackgroundBitmap( m_data->GetOverlayBitmap() ); + + std::vector positions = m_data->GetFieldPositions(); + + DRC_RE_OVERLAY_FIELD* field = AddCheckbox( wxS( "bool_input" ), positions[0] ); + m_boolInputCheckbox = static_cast( field->GetControl() ); + + PositionFields(); + TransferDataToWindow(); +} + + +bool DRC_RE_BOOL_INPUT_OVERLAY_PANEL::TransferDataToWindow() +{ + if( !m_data || !m_boolInputCheckbox ) + return false; + + m_boolInputCheckbox->SetValue( m_data->GetBoolInputValue() ); + + return true; +} + + +bool DRC_RE_BOOL_INPUT_OVERLAY_PANEL::TransferDataFromWindow() +{ + if( !m_data || !m_boolInputCheckbox ) + return false; + + m_data->SetBoolInputValue( m_boolInputCheckbox->GetValue() ); + + return true; +} + + +bool DRC_RE_BOOL_INPUT_OVERLAY_PANEL::ValidateInputs( int* aErrorCount, + std::string* aValidationMessage ) +{ + TransferDataFromWindow(); + + VALIDATION_RESULT result = m_data->Validate(); + + if( !result.isValid ) + { + *aErrorCount = result.errors.size(); + + for( size_t i = 0; i < result.errors.size(); i++ ) + *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage( i + 1, result.errors[i] ); + + return false; + } + + return true; +} + + +wxString DRC_RE_BOOL_INPUT_OVERLAY_PANEL::GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) +{ + if( !m_data ) + return wxEmptyString; + + return m_data->GenerateRule( aContext ); +} diff --git a/pcbnew/drc/rule_editor/drc_re_bool_input_overlay_panel.h b/pcbnew/drc/rule_editor/drc_re_bool_input_overlay_panel.h new file mode 100644 index 0000000000..52a227cf45 --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_bool_input_overlay_panel.h @@ -0,0 +1,57 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef DRC_RE_BOOL_INPUT_OVERLAY_PANEL_H +#define DRC_RE_BOOL_INPUT_OVERLAY_PANEL_H + +#include "drc_re_bitmap_overlay_panel.h" + +class DRC_RE_BOOL_INPUT_CONSTRAINT_DATA; +class wxCheckBox; + + +/** + * Overlay panel for boolean input constraints showing a single checkbox + * positioned over a diagram. + */ +class DRC_RE_BOOL_INPUT_OVERLAY_PANEL : public DRC_RE_BITMAP_OVERLAY_PANEL +{ +public: + DRC_RE_BOOL_INPUT_OVERLAY_PANEL( wxWindow* aParent, + DRC_RE_BOOL_INPUT_CONSTRAINT_DATA* aData ); + + ~DRC_RE_BOOL_INPUT_OVERLAY_PANEL() override = default; + + bool TransferDataToWindow() override; + bool TransferDataFromWindow() override; + + bool ValidateInputs( int* aErrorCount, std::string* aValidationMessage ) override; + wxString GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) override; + +private: + DRC_RE_BOOL_INPUT_CONSTRAINT_DATA* m_data; + + wxCheckBox* m_boolInputCheckbox; +}; + +#endif // DRC_RE_BOOL_INPUT_OVERLAY_PANEL_H diff --git a/pcbnew/drc/rule_editor/drc_re_content_panel_base.h b/pcbnew/drc/rule_editor/drc_re_content_panel_base.h index e89908edc1..ed48c68cd3 100644 --- a/pcbnew/drc/rule_editor/drc_re_content_panel_base.h +++ b/pcbnew/drc/rule_editor/drc_re_content_panel_base.h @@ -54,6 +54,9 @@ public: virtual ~DRC_RULE_EDITOR_CONTENT_PANEL_BASE() = default; + virtual bool TransferDataToWindow() = 0; + virtual bool TransferDataFromWindow() = 0; + virtual bool ValidateInputs( int* aErrorCount, std::string* aValidationMessage ) = 0; virtual wxString GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) = 0; diff --git a/pcbnew/drc/rule_editor/drc_re_min_txt_ht_th_constraint_data.h b/pcbnew/drc/rule_editor/drc_re_min_txt_ht_th_constraint_data.h index a6cf67e03c..33823ebc3a 100644 --- a/pcbnew/drc/rule_editor/drc_re_min_txt_ht_th_constraint_data.h +++ b/pcbnew/drc/rule_editor/drc_re_min_txt_ht_th_constraint_data.h @@ -49,6 +49,21 @@ public: virtual ~DRC_RE_MINIMUM_TEXT_HEIGHT_THICKNESS_CONSTRAINT_DATA() = default; + BITMAPS GetOverlayBitmap() const override + { + return BITMAPS::constraint_minimum_text_height_and_thickness; + } + + std::vector GetFieldPositions() const override + { + // Positions measured from constraint_minimum_text_height_and_thickness.png (~300x200) + // Format: { xStart, xEnd, yTop, tabOrder } + return { + { 230, 310, 55, 1 }, // min_text_height (right side, vertical dimension) + { 140, 220, 165, 2 }, // min_text_thickness (bottom, horizontal dimension) + }; + } + double GetMinTextHeight() { return m_minTextHeight; } void SetMinTextHeight( double aMinTextHeight ) { m_minTextHeight = aMinTextHeight; } diff --git a/pcbnew/drc/rule_editor/drc_re_min_txt_ht_th_overlay_panel.cpp b/pcbnew/drc/rule_editor/drc_re_min_txt_ht_th_overlay_panel.cpp new file mode 100644 index 0000000000..b6035ec6d8 --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_min_txt_ht_th_overlay_panel.cpp @@ -0,0 +1,113 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "drc_re_min_txt_ht_th_overlay_panel.h" +#include "drc_re_min_txt_ht_th_constraint_data.h" +#include "drc_rule_editor_utils.h" + +#include +#include + +#include + + +DRC_RE_MIN_TXT_HT_TH_OVERLAY_PANEL::DRC_RE_MIN_TXT_HT_TH_OVERLAY_PANEL( + wxWindow* aParent, DRC_RE_MINIMUM_TEXT_HEIGHT_THICKNESS_CONSTRAINT_DATA* aData, + EDA_UNITS aUnits ) : + DRC_RE_BITMAP_OVERLAY_PANEL( aParent ), + m_data( aData ), + m_unitsProvider( pcbIUScale, aUnits ) +{ + SetBackgroundBitmap( BITMAPS::constraint_minimum_text_height_and_thickness ); + + std::vector positions = m_data->GetFieldPositions(); + + m_minTextHeightBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "min_text_height" ), positions[0], + m_minTextHeightBinder.get() ); + + m_minTextThicknessBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "min_text_thickness" ), positions[1], + m_minTextThicknessBinder.get() ); + + PositionFields(); + TransferDataToWindow(); +} + + +bool DRC_RE_MIN_TXT_HT_TH_OVERLAY_PANEL::TransferDataToWindow() +{ + if( !m_data ) + return false; + + m_minTextHeightBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetMinTextHeight() ) ); + m_minTextThicknessBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetMinTextThickness() ) ); + + return true; +} + + +bool DRC_RE_MIN_TXT_HT_TH_OVERLAY_PANEL::TransferDataFromWindow() +{ + if( !m_data ) + return false; + + m_data->SetMinTextHeight( pcbIUScale.IUTomm( m_minTextHeightBinder->GetDoubleValue() ) ); + m_data->SetMinTextThickness( pcbIUScale.IUTomm( m_minTextThicknessBinder->GetDoubleValue() ) ); + + return true; +} + + +bool DRC_RE_MIN_TXT_HT_TH_OVERLAY_PANEL::ValidateInputs( int* aErrorCount, + std::string* aValidationMessage ) +{ + TransferDataFromWindow(); + + VALIDATION_RESULT result = m_data->Validate(); + + if( !result.isValid ) + { + *aErrorCount = result.errors.size(); + + for( size_t i = 0; i < result.errors.size(); i++ ) + *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage( i + 1, result.errors[i] ); + + return false; + } + + return true; +} + + +wxString DRC_RE_MIN_TXT_HT_TH_OVERLAY_PANEL::GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) +{ + if( !m_data ) + return wxEmptyString; + + return m_data->GenerateRule( aContext ); +} diff --git a/pcbnew/drc/rule_editor/drc_re_min_txt_ht_th_overlay_panel.h b/pcbnew/drc/rule_editor/drc_re_min_txt_ht_th_overlay_panel.h new file mode 100644 index 0000000000..53e995602c --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_min_txt_ht_th_overlay_panel.h @@ -0,0 +1,67 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef DRC_RE_MIN_TXT_HT_TH_OVERLAY_PANEL_H +#define DRC_RE_MIN_TXT_HT_TH_OVERLAY_PANEL_H + +#include + +#include + +#include "drc_re_bitmap_overlay_panel.h" + +enum class EDA_UNITS; + +class DRC_RE_MINIMUM_TEXT_HEIGHT_THICKNESS_CONSTRAINT_DATA; +class UNIT_BINDER; + + +/** + * Overlay panel for minimum text height and thickness constraints showing text dimension fields + * positioned over a diagram. + */ +class DRC_RE_MIN_TXT_HT_TH_OVERLAY_PANEL : public DRC_RE_BITMAP_OVERLAY_PANEL +{ +public: + DRC_RE_MIN_TXT_HT_TH_OVERLAY_PANEL( wxWindow* aParent, + DRC_RE_MINIMUM_TEXT_HEIGHT_THICKNESS_CONSTRAINT_DATA* aData, + EDA_UNITS aUnits ); + + ~DRC_RE_MIN_TXT_HT_TH_OVERLAY_PANEL() override = default; + + bool TransferDataToWindow() override; + bool TransferDataFromWindow() override; + + bool ValidateInputs( int* aErrorCount, std::string* aValidationMessage ) override; + wxString GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) override; + +private: + DRC_RE_MINIMUM_TEXT_HEIGHT_THICKNESS_CONSTRAINT_DATA* m_data; + + UNITS_PROVIDER m_unitsProvider; + + std::unique_ptr m_minTextHeightBinder; + std::unique_ptr m_minTextThicknessBinder; +}; + +#endif // DRC_RE_MIN_TXT_HT_TH_OVERLAY_PANEL_H diff --git a/pcbnew/drc/rule_editor/drc_re_numeric_input_constraint_data.h b/pcbnew/drc/rule_editor/drc_re_numeric_input_constraint_data.h index 76ae91590c..8372044b72 100644 --- a/pcbnew/drc/rule_editor/drc_re_numeric_input_constraint_data.h +++ b/pcbnew/drc/rule_editor/drc_re_numeric_input_constraint_data.h @@ -46,6 +46,17 @@ public: virtual ~DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA() = default; + BITMAPS GetOverlayBitmap() const override { return BITMAPS::constraint_minimum_track_width; } + + std::vector GetFieldPositions() const override + { + // Positions measured from constraint_minimum_track_width.png (~280x140) + // Format: { xStart, xEnd, yTop, tabOrder } + return { + { 220, 300, 50, 1 }, // value (right side, near dimension arrow) + }; + } + std::vector GetConstraintClauses( const RULE_GENERATION_CONTEXT& aContext ) const override { wxString code = GetConstraintCode(); diff --git a/pcbnew/drc/rule_editor/drc_re_numeric_input_overlay_panel.cpp b/pcbnew/drc/rule_editor/drc_re_numeric_input_overlay_panel.cpp new file mode 100644 index 0000000000..0fc677fdc8 --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_numeric_input_overlay_panel.cpp @@ -0,0 +1,103 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "drc_re_numeric_input_overlay_panel.h" +#include "drc_re_numeric_input_constraint_data.h" +#include "drc_rule_editor_utils.h" + +#include +#include + +#include + + +DRC_RE_NUMERIC_INPUT_OVERLAY_PANEL::DRC_RE_NUMERIC_INPUT_OVERLAY_PANEL( + wxWindow* aParent, DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA* aData, EDA_UNITS aUnits ) : + DRC_RE_BITMAP_OVERLAY_PANEL( aParent ), + m_data( aData ), + m_unitsProvider( pcbIUScale, aUnits ) +{ + SetBackgroundBitmap( m_data->GetOverlayBitmap() ); + + std::vector positions = m_data->GetFieldPositions(); + + m_valueBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "value" ), positions[0], m_valueBinder.get() ); + + PositionFields(); + TransferDataToWindow(); +} + + +bool DRC_RE_NUMERIC_INPUT_OVERLAY_PANEL::TransferDataToWindow() +{ + if( !m_data ) + return false; + + m_valueBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetNumericInputValue() ) ); + + return true; +} + + +bool DRC_RE_NUMERIC_INPUT_OVERLAY_PANEL::TransferDataFromWindow() +{ + if( !m_data ) + return false; + + m_data->SetNumericInputValue( pcbIUScale.IUTomm( m_valueBinder->GetDoubleValue() ) ); + + return true; +} + + +bool DRC_RE_NUMERIC_INPUT_OVERLAY_PANEL::ValidateInputs( int* aErrorCount, + std::string* aValidationMessage ) +{ + TransferDataFromWindow(); + + VALIDATION_RESULT result = m_data->Validate(); + + if( !result.isValid ) + { + *aErrorCount = result.errors.size(); + + for( size_t i = 0; i < result.errors.size(); i++ ) + *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage( i + 1, result.errors[i] ); + + return false; + } + + return true; +} + + +wxString DRC_RE_NUMERIC_INPUT_OVERLAY_PANEL::GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) +{ + if( !m_data ) + return wxEmptyString; + + return m_data->GenerateRule( aContext ); +} diff --git a/pcbnew/drc/rule_editor/drc_re_numeric_input_overlay_panel.h b/pcbnew/drc/rule_editor/drc_re_numeric_input_overlay_panel.h new file mode 100644 index 0000000000..3f92def32b --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_numeric_input_overlay_panel.h @@ -0,0 +1,66 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef DRC_RE_NUMERIC_INPUT_OVERLAY_PANEL_H +#define DRC_RE_NUMERIC_INPUT_OVERLAY_PANEL_H + +#include + +#include + +#include "drc_re_bitmap_overlay_panel.h" + +enum class EDA_UNITS; + +class DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA; +class UNIT_BINDER; + + +/** + * Overlay panel for numeric input constraints showing a single numeric value field + * positioned over a diagram. + */ +class DRC_RE_NUMERIC_INPUT_OVERLAY_PANEL : public DRC_RE_BITMAP_OVERLAY_PANEL +{ +public: + DRC_RE_NUMERIC_INPUT_OVERLAY_PANEL( wxWindow* aParent, + DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA* aData, + EDA_UNITS aUnits ); + + ~DRC_RE_NUMERIC_INPUT_OVERLAY_PANEL() override = default; + + bool TransferDataToWindow() override; + bool TransferDataFromWindow() override; + + bool ValidateInputs( int* aErrorCount, std::string* aValidationMessage ) override; + wxString GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) override; + +private: + DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA* m_data; + + UNITS_PROVIDER m_unitsProvider; + + std::unique_ptr m_valueBinder; +}; + +#endif // DRC_RE_NUMERIC_INPUT_OVERLAY_PANEL_H diff --git a/pcbnew/drc/rule_editor/drc_re_numeric_input_panel.cpp b/pcbnew/drc/rule_editor/drc_re_numeric_input_panel.cpp index 02eca59517..2d1d10db0f 100644 --- a/pcbnew/drc/rule_editor/drc_re_numeric_input_panel.cpp +++ b/pcbnew/drc/rule_editor/drc_re_numeric_input_panel.cpp @@ -31,7 +31,7 @@ const std::map NumericConstraintBitMapPairs = { { BASIC_CLEARANCE, BITMAPS::constraint_basic_clearance }, - { BOARD_OUTLINE_CLEARANCE, BITMAPS::constraint_outline_clearance }, + { BOARD_OUTLINE_CLEARANCE, BITMAPS::constraint_board_outline_clearance }, { MINIMUM_CLEARANCE, BITMAPS::constraint_minimum_clearance }, { MINIMUM_ITEM_CLEARANCE, BITMAPS::constraint_minimum_item_clearance }, { CREEPAGE_DISTANCE, BITMAPS::constraint_creepage_distance}, @@ -47,7 +47,7 @@ const std::map NumericConstraintBitMap { MINIMUM_UVIA_HOLE, BITMAPS::constraint_minimum_uvia_hole }, { MINIMUM_UVIA_DIAMETER, BITMAPS::constraint_minimum_uvia_diameter }, { MINIMUM_VIA_DIAMETER, BITMAPS::constraint_minimum_via_diameter }, - { SILK_TO_SILK_CLEARANCE, BITMAPS::constraint_silk_to_silk_clearance }, + { SILK_TO_SILK_CLEARANCE, BITMAPS::constraint_silk_clearance }, { SILK_TO_SOLDERMASK_CLEARANCE, BITMAPS::constraint_silk_to_soldermask_clearance }, { MINIMUM_SOLDERMASK_SILVER, BITMAPS::constraint_minimum_soldermask_silver }, { SOLDERMASK_EXPANSION, BITMAPS::constraint_soldermask_expansion }, @@ -56,7 +56,7 @@ const std::map NumericConstraintBitMap { MINIMUM_ANGULAR_RING, BITMAPS::constraint_minimum_angular_ring }, { MINIMUM_THERMAL_RELIEF_SPOKE_COUNT, BITMAPS::constraint_minimum_thermal_relief_spoke_count }, { MAXIMUM_VIA_COUNT, BITMAPS::constraint_maximum_via_count }, - { ABSOLUTE_LENGTH, BITMAPS::constraint_absolute_length }, + { ABSOLUTE_LENGTH, BITMAPS::constraint_length }, { MATCHED_LENGTH_DIFF_PAIR, BITMAPS::constraint_matched_length_diff_pair } }; diff --git a/pcbnew/drc/rule_editor/drc_re_overlay_field.cpp b/pcbnew/drc/rule_editor/drc_re_overlay_field.cpp new file mode 100644 index 0000000000..99e96ddecc --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_overlay_field.cpp @@ -0,0 +1,154 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "drc_re_overlay_field.h" + +#include +#include + +#include +#include +#include +#include + + +DRC_RE_OVERLAY_FIELD::DRC_RE_OVERLAY_FIELD( wxWindow* aParent, const wxString& aFieldId, + wxControl* aControl, + const DRC_RE_FIELD_POSITION& aPosition ) : + m_parent( aParent ), + m_fieldId( aFieldId ), + m_control( aControl ), + m_position( aPosition ), + m_getter( nullptr ), + m_setter( nullptr ), + m_unitBinder( nullptr ), + m_errorIcon( nullptr ), + m_showingError( false ), + m_label( nullptr ) +{ +} + + +DRC_RE_OVERLAY_FIELD::~DRC_RE_OVERLAY_FIELD() +{ + if( m_errorIcon ) + { + m_errorIcon->Destroy(); + m_errorIcon = nullptr; + } + + if( m_label ) + { + m_label->Destroy(); + m_label = nullptr; + } +} + + +void DRC_RE_OVERLAY_FIELD::createErrorIcon() +{ + if( m_errorIcon ) + return; + + m_errorIcon = new wxStaticBitmap( m_parent, wxID_ANY, KiBitmapBundle( BITMAPS::small_warning ) ); + + // Position the icon to the right of the control with a small gap + wxPoint controlPos = m_control->GetPosition(); + wxSize controlSize = m_control->GetSize(); + wxSize iconSize = m_errorIcon->GetSize(); + + int iconX = controlPos.x + controlSize.GetWidth() + 4; + int iconY = controlPos.y + ( controlSize.GetHeight() - iconSize.GetHeight() ) / 2; + + m_errorIcon->SetPosition( wxPoint( iconX, iconY ) ); + m_errorIcon->Hide(); +} + + +void DRC_RE_OVERLAY_FIELD::ShowError( bool aShow ) +{ + if( aShow && !m_errorIcon ) + createErrorIcon(); + + if( m_errorIcon ) + m_errorIcon->Show( aShow ); + + m_showingError = aShow; +} + + +bool DRC_RE_OVERLAY_FIELD::TransferToWindow() +{ + if( !m_getter ) + return true; + + try + { + double value = m_getter(); + + if( m_unitBinder ) + { + m_unitBinder->SetDoubleValue( value ); + } + + return true; + } + catch( ... ) + { + return false; + } +} + + +bool DRC_RE_OVERLAY_FIELD::TransferFromWindow() +{ + if( !m_setter ) + return true; + + try + { + if( m_unitBinder ) + { + double value = m_unitBinder->GetDoubleValue(); + m_setter( value ); + } + + return true; + } + catch( ... ) + { + return false; + } +} + + +void DRC_RE_OVERLAY_FIELD::CreateLabel() +{ + if( m_label ) + return; + + if( m_position.labelText.IsEmpty() || m_position.labelPosition == LABEL_POSITION::NONE ) + return; + + m_label = new wxStaticText( m_parent, wxID_ANY, m_position.labelText ); +} diff --git a/pcbnew/drc/rule_editor/drc_re_overlay_field.h b/pcbnew/drc/rule_editor/drc_re_overlay_field.h new file mode 100644 index 0000000000..f8d6c48e75 --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_overlay_field.h @@ -0,0 +1,174 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef DRC_RE_OVERLAY_FIELD_H +#define DRC_RE_OVERLAY_FIELD_H + +#include +#include + +#include "drc_re_overlay_types.h" + +class wxWindow; +class wxControl; +class wxStaticBitmap; +class wxStaticText; +class UNIT_BINDER; + + +/** + * Wraps a wxControl positioned over a bitmap overlay panel. + * + * Manages the control's position within the overlay, data binding via lambda functions, + * optional UNIT_BINDER integration for unit conversion, and error icon display for + * validation feedback. + */ +class DRC_RE_OVERLAY_FIELD +{ +public: + using Getter = std::function; + using Setter = std::function; + + /** + * Construct an overlay field wrapping an existing control. + * + * @param aParent Parent window (typically the overlay panel) + * @param aFieldId Unique identifier for this field, used for error mapping + * @param aControl The wxControl to wrap and position + * @param aPosition Position specification in 1x bitmap coordinates + */ + DRC_RE_OVERLAY_FIELD( wxWindow* aParent, const wxString& aFieldId, wxControl* aControl, + const DRC_RE_FIELD_POSITION& aPosition ); + + ~DRC_RE_OVERLAY_FIELD(); + + /** + * @return The wrapped wxControl. + */ + wxControl* GetControl() const { return m_control; } + + /** + * @return The unique field identifier string. + */ + const wxString& GetFieldId() const { return m_fieldId; } + + /** + * @return The field's position specification in 1x bitmap coordinates. + */ + const DRC_RE_FIELD_POSITION& GetPosition() const { return m_position; } + + /** + * Transfer data from the model to the control. + * + * Uses the getter lambda if set. If a UNIT_BINDER is associated, the value is + * passed through SetDoubleValue for unit conversion. + * + * @return true on success, false if getter throws or is not set + */ + bool TransferToWindow(); + + /** + * Transfer data from the control to the model. + * + * Reads the control value (via UNIT_BINDER if associated) and calls the setter lambda. + * + * @return true on success, false if setter throws or is not set + */ + bool TransferFromWindow(); + + /** + * Set the getter lambda for reading model data. + * + * @param aGetter Function returning the current model value + */ + void SetGetter( Getter aGetter ) { m_getter = std::move( aGetter ); } + + /** + * Set the setter lambda for writing model data. + * + * @param aSetter Function accepting the new value from the control + */ + void SetSetter( Setter aSetter ) { m_setter = std::move( aSetter ); } + + /** + * Associate a UNIT_BINDER for unit conversion. + * + * When set, TransferToWindow and TransferFromWindow use the UNIT_BINDER's + * SetDoubleValue and GetDoubleValue methods for proper unit handling. + * + * @param aBinder The UNIT_BINDER to associate (ownership remains with caller) + */ + void SetUnitBinder( UNIT_BINDER* aBinder ) { m_unitBinder = aBinder; } + + /** + * @return The associated UNIT_BINDER, or nullptr if none. + */ + UNIT_BINDER* GetUnitBinder() const { return m_unitBinder; } + + /** + * Show or hide the error indicator icon adjacent to this field. + * + * @param aShow true to display the error icon, false to hide it + */ + void ShowError( bool aShow ); + + /** + * @return true if the error icon is currently visible. + */ + bool IsShowingError() const { return m_showingError; } + + /** + * @return The label control, or nullptr if no label was created. + */ + wxStaticText* GetLabel() const { return m_label; } + + /** + * @return true if this field has a label. + */ + bool HasLabel() const { return m_label != nullptr; } + + /** + * Create and associate a label with this field. + * The label is positioned according to the LABEL_POSITION in the field position struct. + */ + void CreateLabel(); + +private: + void createErrorIcon(); + + wxWindow* m_parent; + wxString m_fieldId; + wxControl* m_control; + DRC_RE_FIELD_POSITION m_position; + + Getter m_getter; + Setter m_setter; + UNIT_BINDER* m_unitBinder; + + wxStaticBitmap* m_errorIcon; + bool m_showingError; + + wxStaticText* m_label; +}; + +#endif // DRC_RE_OVERLAY_FIELD_H diff --git a/pcbnew/drc/rule_editor/drc_re_overlay_panel_factory.cpp b/pcbnew/drc/rule_editor/drc_re_overlay_panel_factory.cpp new file mode 100644 index 0000000000..5fd1d2c7e9 --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_overlay_panel_factory.cpp @@ -0,0 +1,116 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "drc_re_overlay_panel_factory.h" + +#include "drc_rule_editor_utils.h" + +#include "drc_re_via_style_overlay_panel.h" +#include "drc_re_routing_width_overlay_panel.h" +#include "drc_re_rtg_diff_pair_overlay_panel.h" +#include "drc_re_min_txt_ht_th_overlay_panel.h" +#include "drc_re_abs_length_two_overlay_panel.h" +#include "drc_re_numeric_input_overlay_panel.h" +#include "drc_re_bool_input_overlay_panel.h" +#include "drc_re_allowed_orientation_overlay_panel.h" +#include "drc_re_permitted_layers_overlay_panel.h" + +#include "drc_re_via_style_constraint_data.h" +#include "drc_re_routing_width_constraint_data.h" +#include "drc_re_rtg_diff_pair_constraint_data.h" +#include "drc_re_min_txt_ht_th_constraint_data.h" +#include "drc_re_abs_length_two_constraint_data.h" +#include "drc_re_numeric_input_constraint_data.h" +#include "drc_re_bool_input_constraint_data.h" +#include "drc_re_allowed_orientation_constraint_data.h" +#include "drc_re_permitted_layers_constraint_data.h" + + +DRC_RE_BITMAP_OVERLAY_PANEL* +DRC_RE_OVERLAY_PANEL_FACTORY::CreateOverlayPanel( wxWindow* aParent, + DRC_RULE_EDITOR_CONSTRAINT_NAME aType, + DRC_RE_BASE_CONSTRAINT_DATA* aData, + EDA_UNITS aUnits ) +{ + switch( aType ) + { + case VIA_STYLE: + return new DRC_RE_VIA_STYLE_OVERLAY_PANEL( + aParent, + dynamic_cast( aData ), + aUnits ); + + case ROUTING_WIDTH: + return new DRC_RE_ROUTING_WIDTH_OVERLAY_PANEL( + aParent, + dynamic_cast( aData ), + aUnits ); + + case ROUTING_DIFF_PAIR: + return new DRC_RE_ROUTING_DIFF_PAIR_OVERLAY_PANEL( + aParent, + dynamic_cast( aData ), + aUnits ); + + case MINIMUM_TEXT_HEIGHT_AND_THICKNESS: + return new DRC_RE_MIN_TXT_HT_TH_OVERLAY_PANEL( + aParent, + dynamic_cast( aData ), + aUnits ); + + case ABSOLUTE_LENGTH: + return new DRC_RE_ABS_LENGTH_TWO_OVERLAY_PANEL( + aParent, + dynamic_cast( aData ), + aUnits ); + + case PERMITTED_LAYERS: + return new DRC_RE_PERMITTED_LAYERS_OVERLAY_PANEL( + aParent, + dynamic_cast( aData ) ); + + case ALLOWED_ORIENTATION: + return new DRC_RE_ALLOWED_ORIENTATION_OVERLAY_PANEL( + aParent, + dynamic_cast( aData ) ); + + default: + if( DRC_RULE_EDITOR_UTILS::IsNumericInputType( aType ) ) + { + return new DRC_RE_NUMERIC_INPUT_OVERLAY_PANEL( + aParent, + dynamic_cast( aData ), + aUnits ); + } + else if( DRC_RULE_EDITOR_UTILS::IsBoolInputType( aType ) ) + { + return new DRC_RE_BOOL_INPUT_OVERLAY_PANEL( + aParent, + dynamic_cast( aData ) ); + } + + break; + } + + return nullptr; +} diff --git a/pcbnew/drc/rule_editor/drc_re_overlay_panel_factory.h b/pcbnew/drc/rule_editor/drc_re_overlay_panel_factory.h new file mode 100644 index 0000000000..b857528c1a --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_overlay_panel_factory.h @@ -0,0 +1,67 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef DRC_RE_OVERLAY_PANEL_FACTORY_H +#define DRC_RE_OVERLAY_PANEL_FACTORY_H + +#include + +#include "drc_rule_editor_enums.h" + +class wxWindow; +class DRC_RE_BITMAP_OVERLAY_PANEL; +class DRC_RE_BASE_CONSTRAINT_DATA; + + +/** + * Factory for creating overlay panels for DRC constraint editing. + * + * Maps constraint types to their corresponding bitmap overlay panel classes. The overlay + * panels display constraint diagrams with input fields positioned over the artwork. + */ +class DRC_RE_OVERLAY_PANEL_FACTORY +{ +public: + /** + * Create an overlay panel for the given constraint type. + * + * Returns the appropriate overlay panel subclass based on the constraint type. For + * constraints that don't have a specialized overlay panel (e.g., custom rules), + * returns nullptr. + * + * @param aParent The parent window for the overlay panel. + * @param aType The constraint type determining which panel class to create. + * @param aData The constraint data to bind to the panel. The factory will cast this + * to the appropriate derived type based on aType. + * @param aUnits The unit system for displaying values. Ignored for constraint types + * that don't display dimensional values. + * @return The created overlay panel, or nullptr if the constraint type doesn't support + * bitmap overlays. + */ + static DRC_RE_BITMAP_OVERLAY_PANEL* CreateOverlayPanel( wxWindow* aParent, + DRC_RULE_EDITOR_CONSTRAINT_NAME aType, + DRC_RE_BASE_CONSTRAINT_DATA* aData, + EDA_UNITS aUnits ); +}; + +#endif // DRC_RE_OVERLAY_PANEL_FACTORY_H diff --git a/pcbnew/drc/rule_editor/drc_re_overlay_types.h b/pcbnew/drc/rule_editor/drc_re_overlay_types.h new file mode 100644 index 0000000000..bcea766209 --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_overlay_types.h @@ -0,0 +1,82 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef DRC_RE_OVERLAY_TYPES_H +#define DRC_RE_OVERLAY_TYPES_H + +#include + + +/** + * Specifies the position of a label relative to its associated field. + */ +enum class LABEL_POSITION +{ + NONE, ///< No label + LEFT, ///< Label to the left of the field + RIGHT, ///< Label to the right of the field + TOP, ///< Label above the field + BOTTOM ///< Label below the field +}; + + +/** + * Specifies the position and size of a field overlaid on a constraint bitmap. + * + * All coordinates are in 1x bitmap pixels. When the system selects a higher-resolution + * bitmap (1.5x or 2x), these values are automatically scaled at runtime. + */ +struct DRC_RE_FIELD_POSITION +{ + int xStart; ///< Left edge X coordinate where the field starts + int xEnd; ///< Right edge X coordinate where the field ends + int yTop; ///< Top edge Y coordinate of the field + int tabOrder; ///< Tab navigation order (1-based, lower numbers receive focus first) + + wxString labelText; ///< Optional label text (empty for no label) + LABEL_POSITION labelPosition; ///< Position of label relative to field + + DRC_RE_FIELD_POSITION() : + xStart( 0 ), + xEnd( 0 ), + yTop( 0 ), + tabOrder( 0 ), + labelText(), + labelPosition( LABEL_POSITION::NONE ) + { + } + + DRC_RE_FIELD_POSITION( int aXStart, int aXEnd, int aYTop, int aTabOrder, + const wxString& aLabelText = wxEmptyString, + LABEL_POSITION aLabelPos = LABEL_POSITION::NONE ) : + xStart( aXStart ), + xEnd( aXEnd ), + yTop( aYTop ), + tabOrder( aTabOrder ), + labelText( aLabelText ), + labelPosition( aLabelPos ) + { + } +}; + +#endif // DRC_RE_OVERLAY_TYPES_H diff --git a/pcbnew/drc/rule_editor/drc_re_permitted_layers_constraint_data.h b/pcbnew/drc/rule_editor/drc_re_permitted_layers_constraint_data.h index bf25916fba..e3c2b5857a 100644 --- a/pcbnew/drc/rule_editor/drc_re_permitted_layers_constraint_data.h +++ b/pcbnew/drc/rule_editor/drc_re_permitted_layers_constraint_data.h @@ -47,6 +47,18 @@ public: virtual ~DRC_RE_PERMITTED_LAYERS_CONSTRAINT_DATA() = default; + BITMAPS GetOverlayBitmap() const override { return BITMAPS::constraint_permitted_layers; } + + std::vector GetFieldPositions() const override + { + // Positions measured from constraint_permitted_layers.png (~300x170) + // Format: { xStart, xEnd, yTop, tabOrder } + return { + { 20, 60, 35, 1 }, // top layer checkbox (upper left) + { 20, 60, 120, 2 }, // bottom layer checkbox (lower left) + }; + } + VALIDATION_RESULT Validate() const override { VALIDATION_RESULT result; diff --git a/pcbnew/drc/rule_editor/drc_re_permitted_layers_overlay_panel.cpp b/pcbnew/drc/rule_editor/drc_re_permitted_layers_overlay_panel.cpp new file mode 100644 index 0000000000..2809f6002a --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_permitted_layers_overlay_panel.cpp @@ -0,0 +1,104 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "drc_re_permitted_layers_overlay_panel.h" +#include "drc_re_permitted_layers_constraint_data.h" +#include "drc_rule_editor_utils.h" + +#include + + +DRC_RE_PERMITTED_LAYERS_OVERLAY_PANEL::DRC_RE_PERMITTED_LAYERS_OVERLAY_PANEL( + wxWindow* aParent, DRC_RE_PERMITTED_LAYERS_CONSTRAINT_DATA* aData ) : + DRC_RE_BITMAP_OVERLAY_PANEL( aParent ), + m_data( aData ), + m_topLayerCheckbox( nullptr ), + m_bottomLayerCheckbox( nullptr ) +{ + SetBackgroundBitmap( m_data->GetOverlayBitmap() ); + + std::vector positions = m_data->GetFieldPositions(); + + DRC_RE_OVERLAY_FIELD* topField = AddCheckbox( wxS( "top_layer" ), positions[0] ); + m_topLayerCheckbox = static_cast( topField->GetControl() ); + + DRC_RE_OVERLAY_FIELD* bottomField = AddCheckbox( wxS( "bottom_layer" ), positions[1] ); + m_bottomLayerCheckbox = static_cast( bottomField->GetControl() ); + + PositionFields(); + TransferDataToWindow(); +} + + +bool DRC_RE_PERMITTED_LAYERS_OVERLAY_PANEL::TransferDataToWindow() +{ + if( !m_data || !m_topLayerCheckbox || !m_bottomLayerCheckbox ) + return false; + + m_topLayerCheckbox->SetValue( m_data->GetTopLayerEnabled() ); + m_bottomLayerCheckbox->SetValue( m_data->GetBottomLayerEnabled() ); + + return true; +} + + +bool DRC_RE_PERMITTED_LAYERS_OVERLAY_PANEL::TransferDataFromWindow() +{ + if( !m_data || !m_topLayerCheckbox || !m_bottomLayerCheckbox ) + return false; + + m_data->SetTopLayerEnabled( m_topLayerCheckbox->GetValue() ); + m_data->SetBottomLayerEnabled( m_bottomLayerCheckbox->GetValue() ); + + return true; +} + + +bool DRC_RE_PERMITTED_LAYERS_OVERLAY_PANEL::ValidateInputs( int* aErrorCount, + std::string* aValidationMessage ) +{ + TransferDataFromWindow(); + + VALIDATION_RESULT result = m_data->Validate(); + + if( !result.isValid ) + { + *aErrorCount = result.errors.size(); + + for( size_t i = 0; i < result.errors.size(); i++ ) + *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage( i + 1, result.errors[i] ); + + return false; + } + + return true; +} + + +wxString DRC_RE_PERMITTED_LAYERS_OVERLAY_PANEL::GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) +{ + if( !m_data ) + return wxEmptyString; + + return m_data->GenerateRule( aContext ); +} diff --git a/pcbnew/drc/rule_editor/drc_re_permitted_layers_overlay_panel.h b/pcbnew/drc/rule_editor/drc_re_permitted_layers_overlay_panel.h new file mode 100644 index 0000000000..22493d2d3f --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_permitted_layers_overlay_panel.h @@ -0,0 +1,58 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef DRC_RE_PERMITTED_LAYERS_OVERLAY_PANEL_H +#define DRC_RE_PERMITTED_LAYERS_OVERLAY_PANEL_H + +#include "drc_re_bitmap_overlay_panel.h" + +class DRC_RE_PERMITTED_LAYERS_CONSTRAINT_DATA; +class wxCheckBox; + + +/** + * Overlay panel for permitted layers constraints showing checkboxes + * for top and bottom layer selection positioned over a diagram. + */ +class DRC_RE_PERMITTED_LAYERS_OVERLAY_PANEL : public DRC_RE_BITMAP_OVERLAY_PANEL +{ +public: + DRC_RE_PERMITTED_LAYERS_OVERLAY_PANEL( wxWindow* aParent, + DRC_RE_PERMITTED_LAYERS_CONSTRAINT_DATA* aData ); + + ~DRC_RE_PERMITTED_LAYERS_OVERLAY_PANEL() override = default; + + bool TransferDataToWindow() override; + bool TransferDataFromWindow() override; + + bool ValidateInputs( int* aErrorCount, std::string* aValidationMessage ) override; + wxString GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) override; + +private: + DRC_RE_PERMITTED_LAYERS_CONSTRAINT_DATA* m_data; + + wxCheckBox* m_topLayerCheckbox; + wxCheckBox* m_bottomLayerCheckbox; +}; + +#endif // DRC_RE_PERMITTED_LAYERS_OVERLAY_PANEL_H diff --git a/pcbnew/drc/rule_editor/drc_re_routing_width_constraint_data.h b/pcbnew/drc/rule_editor/drc_re_routing_width_constraint_data.h index e255d3a53a..6839e3f51a 100644 --- a/pcbnew/drc/rule_editor/drc_re_routing_width_constraint_data.h +++ b/pcbnew/drc/rule_editor/drc_re_routing_width_constraint_data.h @@ -49,6 +49,19 @@ public: virtual ~DRC_RE_ROUTING_WIDTH_CONSTRAINT_DATA() = default; + BITMAPS GetOverlayBitmap() const override { return BITMAPS::constraint_routing_width; } + + std::vector GetFieldPositions() const override + { + // Positions measured from constraint_routing_width.png bitmap + // Format: { xStart, xEnd, yTop, tabOrder } + return { + { 75, 135, 35, 1 }, // min_width (left arrow) + { 145, 205, 85, 2 }, // opt_width (bottom center arrow) + { 215, 275, 35, 3 }, // max_width (right arrow) + }; + } + VALIDATION_RESULT Validate() const override { VALIDATION_RESULT result; diff --git a/pcbnew/drc/rule_editor/drc_re_routing_width_overlay_panel.cpp b/pcbnew/drc/rule_editor/drc_re_routing_width_overlay_panel.cpp new file mode 100644 index 0000000000..a574afa657 --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_routing_width_overlay_panel.cpp @@ -0,0 +1,125 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "drc_re_routing_width_overlay_panel.h" +#include "drc_re_routing_width_constraint_data.h" +#include "drc_rule_editor_utils.h" + +#include +#include + +#include + + +DRC_RE_ROUTING_WIDTH_OVERLAY_PANEL::DRC_RE_ROUTING_WIDTH_OVERLAY_PANEL( + wxWindow* aParent, + DRC_RE_ROUTING_WIDTH_CONSTRAINT_DATA* aData, + EDA_UNITS aUnits ) : + DRC_RE_BITMAP_OVERLAY_PANEL( aParent ), + m_data( aData ), + m_unitsProvider( pcbIUScale, aUnits ) +{ + SetBackgroundBitmap( BITMAPS::constraint_routing_width ); + + std::vector positions = m_data->GetFieldPositions(); + + // Create min width field + m_minRoutingWidthBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "min_width" ), positions[0], m_minRoutingWidthBinder.get() ); + + // Create preferred width field + m_preferredRoutingWidthBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "pref_width" ), positions[1], m_preferredRoutingWidthBinder.get() ); + + // Create max width field + m_maxRoutingWidthBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "max_width" ), positions[2], m_maxRoutingWidthBinder.get() ); + + // Position all fields and update the panel layout + PositionFields(); + TransferDataToWindow(); +} + + +bool DRC_RE_ROUTING_WIDTH_OVERLAY_PANEL::TransferDataToWindow() +{ + if( !m_data ) + return false; + + // Convert mm values to internal units and set them in the binders + m_minRoutingWidthBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetMinRoutingWidth() ) ); + m_preferredRoutingWidthBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetPreferredRoutingWidth() ) ); + m_maxRoutingWidthBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetMaxRoutingWidth() ) ); + + return true; +} + + +bool DRC_RE_ROUTING_WIDTH_OVERLAY_PANEL::TransferDataFromWindow() +{ + if( !m_data ) + return false; + + // Read values from binders (in internal units) and convert to mm for storage + m_data->SetMinRoutingWidth( pcbIUScale.IUTomm( m_minRoutingWidthBinder->GetDoubleValue() ) ); + m_data->SetPreferredRoutingWidth( pcbIUScale.IUTomm( m_preferredRoutingWidthBinder->GetDoubleValue() ) ); + m_data->SetMaxRoutingWidth( pcbIUScale.IUTomm( m_maxRoutingWidthBinder->GetDoubleValue() ) ); + + return true; +} + + +bool DRC_RE_ROUTING_WIDTH_OVERLAY_PANEL::ValidateInputs( int* aErrorCount, + std::string* aValidationMessage ) +{ + TransferDataFromWindow(); + + VALIDATION_RESULT result = m_data->Validate(); + + if( !result.isValid ) + { + *aErrorCount = result.errors.size(); + + for( size_t i = 0; i < result.errors.size(); i++ ) + *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage( i + 1, result.errors[i] ); + + return false; + } + + return true; +} + + +wxString DRC_RE_ROUTING_WIDTH_OVERLAY_PANEL::GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) +{ + if( !m_data ) + return wxEmptyString; + + return m_data->GenerateRule( aContext ); +} diff --git a/pcbnew/drc/rule_editor/drc_re_routing_width_overlay_panel.h b/pcbnew/drc/rule_editor/drc_re_routing_width_overlay_panel.h new file mode 100644 index 0000000000..58874cc38a --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_routing_width_overlay_panel.h @@ -0,0 +1,68 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef DRC_RE_ROUTING_WIDTH_OVERLAY_PANEL_H +#define DRC_RE_ROUTING_WIDTH_OVERLAY_PANEL_H + +#include + +#include + +#include "drc_re_bitmap_overlay_panel.h" + +enum class EDA_UNITS; + +class DRC_RE_ROUTING_WIDTH_CONSTRAINT_DATA; +class UNIT_BINDER; + + +/** + * Overlay panel for routing width constraints showing min/preferred/max width fields + * positioned over a diagram. + */ +class DRC_RE_ROUTING_WIDTH_OVERLAY_PANEL : public DRC_RE_BITMAP_OVERLAY_PANEL +{ +public: + DRC_RE_ROUTING_WIDTH_OVERLAY_PANEL( wxWindow* aParent, + DRC_RE_ROUTING_WIDTH_CONSTRAINT_DATA* aData, + EDA_UNITS aUnits ); + + ~DRC_RE_ROUTING_WIDTH_OVERLAY_PANEL() override = default; + + bool TransferDataToWindow() override; + bool TransferDataFromWindow() override; + + bool ValidateInputs( int* aErrorCount, std::string* aValidationMessage ) override; + wxString GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) override; + +private: + DRC_RE_ROUTING_WIDTH_CONSTRAINT_DATA* m_data; + + UNITS_PROVIDER m_unitsProvider; + + std::unique_ptr m_minRoutingWidthBinder; + std::unique_ptr m_preferredRoutingWidthBinder; + std::unique_ptr m_maxRoutingWidthBinder; +}; + +#endif // DRC_RE_ROUTING_WIDTH_OVERLAY_PANEL_H diff --git a/pcbnew/drc/rule_editor/drc_re_rtg_diff_pair_constraint_data.h b/pcbnew/drc/rule_editor/drc_re_rtg_diff_pair_constraint_data.h index d5bfd1e2da..cafe858d52 100644 --- a/pcbnew/drc/rule_editor/drc_re_rtg_diff_pair_constraint_data.h +++ b/pcbnew/drc/rule_editor/drc_re_rtg_diff_pair_constraint_data.h @@ -52,6 +52,23 @@ public: virtual ~DRC_RE_ROUTING_DIFF_PAIR_CONSTRAINT_DATA() = default; + BITMAPS GetOverlayBitmap() const override { return BITMAPS::constraint_routing_diff_pair; } + + std::vector GetFieldPositions() const override + { + // Positions measured from constraint_routing_diff_pair.png bitmap (~570x160) + // Format: { xStart, xEnd, yTop, tabOrder } + return { + { 95, 155, 30, 1 }, // min_width (left side, top arrow) + { 95, 155, 55, 2 }, // opt_width (left side, middle) + { 95, 155, 80, 3 }, // max_width (left side, bottom) + { 195, 255, 30, 4 }, // min_gap (center-left, top) + { 195, 255, 55, 5 }, // opt_gap (center-left, middle) + { 195, 255, 80, 6 }, // max_gap (center-left, bottom) + { 420, 520, 55, 7 }, // max_uncoupled (right side) + }; + } + VALIDATION_RESULT Validate() const override { VALIDATION_RESULT result; diff --git a/pcbnew/drc/rule_editor/drc_re_rtg_diff_pair_overlay_panel.cpp b/pcbnew/drc/rule_editor/drc_re_rtg_diff_pair_overlay_panel.cpp new file mode 100644 index 0000000000..63e375986d --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_rtg_diff_pair_overlay_panel.cpp @@ -0,0 +1,157 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "drc_re_rtg_diff_pair_overlay_panel.h" +#include "drc_re_rtg_diff_pair_constraint_data.h" +#include "drc_rule_editor_utils.h" + +#include +#include + +#include + + +DRC_RE_ROUTING_DIFF_PAIR_OVERLAY_PANEL::DRC_RE_ROUTING_DIFF_PAIR_OVERLAY_PANEL( + wxWindow* aParent, + DRC_RE_ROUTING_DIFF_PAIR_CONSTRAINT_DATA* aData, + EDA_UNITS aUnits ) : + DRC_RE_BITMAP_OVERLAY_PANEL( aParent ), + m_data( aData ), + m_unitsProvider( pcbIUScale, aUnits ) +{ + SetBackgroundBitmap( BITMAPS::constraint_routing_diff_pair ); + + std::vector positions = m_data->GetFieldPositions(); + + // Create gap fields (min/pref/max) + m_minGapBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "min_gap" ), positions[0], m_minGapBinder.get() ); + + m_preferredGapBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "pref_gap" ), positions[1], m_preferredGapBinder.get() ); + + m_maxGapBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "max_gap" ), positions[2], m_maxGapBinder.get() ); + + // Create width fields (min/pref/max) + m_minWidthBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "min_width" ), positions[3], m_minWidthBinder.get() ); + + m_preferredWidthBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "pref_width" ), positions[4], m_preferredWidthBinder.get() ); + + m_maxWidthBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "max_width" ), positions[5], m_maxWidthBinder.get() ); + + // Create max uncoupled length field + m_maxUncoupledLengthBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "max_uncoupled" ), positions[6], m_maxUncoupledLengthBinder.get() ); + + // Position all fields and update the panel layout + PositionFields(); + TransferDataToWindow(); +} + + +bool DRC_RE_ROUTING_DIFF_PAIR_OVERLAY_PANEL::TransferDataToWindow() +{ + if( !m_data ) + return false; + + // Convert mm values to internal units and set them in the binders + m_minGapBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetMinGap() ) ); + m_preferredGapBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetPreferredGap() ) ); + m_maxGapBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetMaxGap() ) ); + + m_minWidthBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetMinWidth() ) ); + m_preferredWidthBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetPreferredWidth() ) ); + m_maxWidthBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetMaxWidth() ) ); + + m_maxUncoupledLengthBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetMaxUncoupledLength() ) ); + + return true; +} + + +bool DRC_RE_ROUTING_DIFF_PAIR_OVERLAY_PANEL::TransferDataFromWindow() +{ + if( !m_data ) + return false; + + // Read values from binders (in internal units) and convert to mm for storage + m_data->SetMinGap( pcbIUScale.IUTomm( m_minGapBinder->GetDoubleValue() ) ); + m_data->SetPreferredGap( pcbIUScale.IUTomm( m_preferredGapBinder->GetDoubleValue() ) ); + m_data->SetMaxGap( pcbIUScale.IUTomm( m_maxGapBinder->GetDoubleValue() ) ); + + m_data->SetMinWidth( pcbIUScale.IUTomm( m_minWidthBinder->GetDoubleValue() ) ); + m_data->SetPreferredWidth( pcbIUScale.IUTomm( m_preferredWidthBinder->GetDoubleValue() ) ); + m_data->SetMaxWidth( pcbIUScale.IUTomm( m_maxWidthBinder->GetDoubleValue() ) ); + + m_data->SetMaxUncoupledLength( pcbIUScale.IUTomm( m_maxUncoupledLengthBinder->GetDoubleValue() ) ); + + return true; +} + + +bool DRC_RE_ROUTING_DIFF_PAIR_OVERLAY_PANEL::ValidateInputs( int* aErrorCount, + std::string* aValidationMessage ) +{ + TransferDataFromWindow(); + + VALIDATION_RESULT result = m_data->Validate(); + + if( !result.isValid ) + { + *aErrorCount = result.errors.size(); + + for( size_t i = 0; i < result.errors.size(); i++ ) + *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage( i + 1, result.errors[i] ); + + return false; + } + + return true; +} + + +wxString DRC_RE_ROUTING_DIFF_PAIR_OVERLAY_PANEL::GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) +{ + if( !m_data ) + return wxEmptyString; + + return m_data->GenerateRule( aContext ); +} diff --git a/pcbnew/drc/rule_editor/drc_re_rtg_diff_pair_overlay_panel.h b/pcbnew/drc/rule_editor/drc_re_rtg_diff_pair_overlay_panel.h new file mode 100644 index 0000000000..b04e197229 --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_rtg_diff_pair_overlay_panel.h @@ -0,0 +1,71 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef DRC_RE_RTG_DIFF_PAIR_OVERLAY_PANEL_H +#define DRC_RE_RTG_DIFF_PAIR_OVERLAY_PANEL_H + +#include + +#include + +#include "drc_re_bitmap_overlay_panel.h" + +enum class EDA_UNITS; + +class DRC_RE_ROUTING_DIFF_PAIR_CONSTRAINT_DATA; +class UNIT_BINDER; + +/** + * Overlay panel for differential pair routing constraints showing gap, width, + * and uncoupled length fields positioned over a diagram. + */ +class DRC_RE_ROUTING_DIFF_PAIR_OVERLAY_PANEL : public DRC_RE_BITMAP_OVERLAY_PANEL +{ +public: + DRC_RE_ROUTING_DIFF_PAIR_OVERLAY_PANEL( wxWindow* aParent, + DRC_RE_ROUTING_DIFF_PAIR_CONSTRAINT_DATA* aData, + EDA_UNITS aUnits ); + + ~DRC_RE_ROUTING_DIFF_PAIR_OVERLAY_PANEL() override = default; + + bool TransferDataToWindow() override; + bool TransferDataFromWindow() override; + + bool ValidateInputs( int* aErrorCount, std::string* aValidationMessage ) override; + wxString GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) override; + +private: + DRC_RE_ROUTING_DIFF_PAIR_CONSTRAINT_DATA* m_data; + + UNITS_PROVIDER m_unitsProvider; + + std::unique_ptr m_minGapBinder; + std::unique_ptr m_preferredGapBinder; + std::unique_ptr m_maxGapBinder; + std::unique_ptr m_minWidthBinder; + std::unique_ptr m_preferredWidthBinder; + std::unique_ptr m_maxWidthBinder; + std::unique_ptr m_maxUncoupledLengthBinder; +}; + +#endif // DRC_RE_RTG_DIFF_PAIR_OVERLAY_PANEL_H diff --git a/pcbnew/drc/rule_editor/drc_re_via_style_constraint_data.h b/pcbnew/drc/rule_editor/drc_re_via_style_constraint_data.h index ae876770c6..907bf1b657 100644 --- a/pcbnew/drc/rule_editor/drc_re_via_style_constraint_data.h +++ b/pcbnew/drc/rule_editor/drc_re_via_style_constraint_data.h @@ -51,6 +51,22 @@ public: virtual ~DRC_RE_VIA_STYLE_CONSTRAINT_DATA() = default; + BITMAPS GetOverlayBitmap() const override { return BITMAPS::constraint_via_style; } + + std::vector GetFieldPositions() const override + { + // Positions measured from constraint_via_style.png bitmap + // Format: { xStart, xEnd, yTop, tabOrder } + return { + { 260, 340, 25, 1 }, // min_via_diameter (right side, top) + { 260, 340, 55, 2 }, // opt_via_diameter (right side, middle) + { 260, 340, 85, 3 }, // max_via_diameter (right side, bottom) + { 260, 340, 115, 4 }, // min_via_hole (right side, below diameter) + { 260, 340, 145, 5 }, // opt_via_hole + { 260, 340, 175, 6 }, // max_via_hole + }; + } + VALIDATION_RESULT Validate() const override { VALIDATION_RESULT result; diff --git a/pcbnew/drc/rule_editor/drc_re_via_style_overlay_panel.cpp b/pcbnew/drc/rule_editor/drc_re_via_style_overlay_panel.cpp new file mode 100644 index 0000000000..3260d6dadc --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_via_style_overlay_panel.cpp @@ -0,0 +1,150 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "drc_re_via_style_overlay_panel.h" +#include "drc_re_via_style_constraint_data.h" +#include "drc_rule_editor_utils.h" + +#include +#include + +#include + + +DRC_RE_VIA_STYLE_OVERLAY_PANEL::DRC_RE_VIA_STYLE_OVERLAY_PANEL( + wxWindow* aParent, DRC_RE_VIA_STYLE_CONSTRAINT_DATA* aData, EDA_UNITS aUnits ) : + DRC_RE_BITMAP_OVERLAY_PANEL( aParent ), + m_data( aData ), + m_unitsProvider( pcbIUScale, aUnits ) +{ + SetBackgroundBitmap( BITMAPS::constraint_via_style ); + + std::vector positions = m_data->GetFieldPositions(); + + // Create via diameter fields (min/pref/max) + m_minViaDiameterBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "min_via_diameter" ), positions[0], + m_minViaDiameterBinder.get() ); + + m_maxViaDiameterBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "max_via_diameter" ), positions[1], + m_maxViaDiameterBinder.get() ); + + m_prefViaDiameterBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "pref_via_diameter" ), positions[2], + m_prefViaDiameterBinder.get() ); + + // Create via hole size fields (min/pref/max) + m_minViaHoleSizeBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "min_via_hole" ), positions[3], + m_minViaHoleSizeBinder.get() ); + + m_maxViaHoleSizeBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "max_via_hole" ), positions[4], + m_maxViaHoleSizeBinder.get() ); + + m_prefViaHoleSizeBinder = std::make_unique( + &m_unitsProvider, this, nullptr, nullptr, nullptr, false, false ); + + AddFieldWithUnits( wxS( "pref_via_hole" ), positions[5], + m_prefViaHoleSizeBinder.get() ); + + // Position all fields and update the panel layout + PositionFields(); + TransferDataToWindow(); +} + + +bool DRC_RE_VIA_STYLE_OVERLAY_PANEL::TransferDataToWindow() +{ + if( !m_data ) + return false; + + // Convert mm values to internal units and set them in the unit binders + m_minViaDiameterBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetMinViaDiameter() ) ); + m_prefViaDiameterBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetPreferredViaDiameter() ) ); + m_maxViaDiameterBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetMaxViaDiameter() ) ); + + m_minViaHoleSizeBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetMinViaHoleSize() ) ); + m_prefViaHoleSizeBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetPreferredViaHoleSize() ) ); + m_maxViaHoleSizeBinder->SetDoubleValue( pcbIUScale.mmToIU( m_data->GetMaxViaHoleSize() ) ); + + return true; +} + + +bool DRC_RE_VIA_STYLE_OVERLAY_PANEL::TransferDataFromWindow() +{ + if( !m_data ) + return false; + + // Read values from unit binders and convert from internal units to mm + m_data->SetMinViaDiameter( pcbIUScale.IUTomm( m_minViaDiameterBinder->GetDoubleValue() ) ); + m_data->SetPreferredViaDiameter( pcbIUScale.IUTomm( m_prefViaDiameterBinder->GetDoubleValue() ) ); + m_data->SetMaxViaDiameter( pcbIUScale.IUTomm( m_maxViaDiameterBinder->GetDoubleValue() ) ); + + m_data->SetMinViaHoleSize( pcbIUScale.IUTomm( m_minViaHoleSizeBinder->GetDoubleValue() ) ); + m_data->SetPreferredViaHoleSize( pcbIUScale.IUTomm( m_prefViaHoleSizeBinder->GetDoubleValue() ) ); + m_data->SetMaxViaHoleSize( pcbIUScale.IUTomm( m_maxViaHoleSizeBinder->GetDoubleValue() ) ); + + return true; +} + + +bool DRC_RE_VIA_STYLE_OVERLAY_PANEL::ValidateInputs( int* aErrorCount, std::string* aValidationMessage ) +{ + TransferDataFromWindow(); + + VALIDATION_RESULT result = m_data->Validate(); + + if( !result.isValid ) + { + *aErrorCount = result.errors.size(); + + for( size_t i = 0; i < result.errors.size(); i++ ) + *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage( i + 1, result.errors[i] ); + + return false; + } + + return true; +} + + +wxString DRC_RE_VIA_STYLE_OVERLAY_PANEL::GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) +{ + if( !m_data ) + return wxEmptyString; + + return m_data->GenerateRule( aContext ); +} diff --git a/pcbnew/drc/rule_editor/drc_re_via_style_overlay_panel.h b/pcbnew/drc/rule_editor/drc_re_via_style_overlay_panel.h new file mode 100644 index 0000000000..e3a74d23a9 --- /dev/null +++ b/pcbnew/drc/rule_editor/drc_re_via_style_overlay_panel.h @@ -0,0 +1,74 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef DRC_RE_VIA_STYLE_OVERLAY_PANEL_H +#define DRC_RE_VIA_STYLE_OVERLAY_PANEL_H + +#include + +#include + +#include "drc_re_bitmap_overlay_panel.h" + +enum class EDA_UNITS; + +class DRC_RE_VIA_STYLE_CONSTRAINT_DATA; +class UNIT_BINDER; + + +/** + * Overlay panel for via style constraints showing via diameter and hole size fields + * positioned over a diagram. + */ +class DRC_RE_VIA_STYLE_OVERLAY_PANEL : public DRC_RE_BITMAP_OVERLAY_PANEL +{ +public: + DRC_RE_VIA_STYLE_OVERLAY_PANEL( wxWindow* aParent, + DRC_RE_VIA_STYLE_CONSTRAINT_DATA* aData, + EDA_UNITS aUnits ); + + ~DRC_RE_VIA_STYLE_OVERLAY_PANEL() override = default; + + bool TransferDataToWindow() override; + bool TransferDataFromWindow() override; + + bool ValidateInputs( int* aErrorCount, std::string* aValidationMessage ) override; + wxString GenerateRule( const RULE_GENERATION_CONTEXT& aContext ) override; + +private: + DRC_RE_VIA_STYLE_CONSTRAINT_DATA* m_data; + + UNITS_PROVIDER m_unitsProvider; + + // Unit binders for via diameter fields + std::unique_ptr m_minViaDiameterBinder; + std::unique_ptr m_prefViaDiameterBinder; + std::unique_ptr m_maxViaDiameterBinder; + + // Unit binders for via hole size fields + std::unique_ptr m_minViaHoleSizeBinder; + std::unique_ptr m_prefViaHoleSizeBinder; + std::unique_ptr m_maxViaHoleSizeBinder; +}; + +#endif // DRC_RE_VIA_STYLE_OVERLAY_PANEL_H diff --git a/pcbnew/drc/rule_editor/panel_drc_rule_editor.cpp b/pcbnew/drc/rule_editor/panel_drc_rule_editor.cpp index e34ebb3ebb..3212c3a9af 100644 --- a/pcbnew/drc/rule_editor/panel_drc_rule_editor.cpp +++ b/pcbnew/drc/rule_editor/panel_drc_rule_editor.cpp @@ -61,6 +61,19 @@ #include #include #include "drc_re_condition_group_panel.h" + +// Overlay panels (new bitmap-based implementation) +#include "drc_re_via_style_overlay_panel.h" +#include "drc_re_routing_width_overlay_panel.h" +#include "drc_re_rtg_diff_pair_overlay_panel.h" +#include "drc_re_min_txt_ht_th_overlay_panel.h" +#include "drc_re_abs_length_two_overlay_panel.h" +#include "drc_re_numeric_input_overlay_panel.h" +#include "drc_re_bool_input_overlay_panel.h" +#include "drc_re_allowed_orientation_overlay_panel.h" +#include "drc_re_permitted_layers_overlay_panel.h" + +#include #include "drc_re_numeric_input_constraint_data.h" #include "drc_re_bool_input_constraint_data.h" #include "drc_re_via_style_constraint_data.h" @@ -209,13 +222,17 @@ bool PANEL_DRC_RULE_EDITOR::TransferDataToWindow() m_conditionGroupPanel->ParseCondition( cond ); } - return dynamic_cast( m_constraintPanel )->TransferDataToWindow(); + if( m_constraintPanel ) + return m_constraintPanel->TransferDataToWindow(); + + return true; } bool PANEL_DRC_RULE_EDITOR::TransferDataFromWindow() { - dynamic_cast( m_constraintPanel )->TransferDataFromWindow(); + if( m_constraintPanel ) + m_constraintPanel->TransferDataFromWindow(); m_constraintData->SetRuleName( m_nameCtrl->GetValue() ); m_constraintData->SetComment( m_commentCtrl->GetValue() ); @@ -245,65 +262,68 @@ bool PANEL_DRC_RULE_EDITOR::TransferDataFromWindow() DRC_RULE_EDITOR_CONTENT_PANEL_BASE* PANEL_DRC_RULE_EDITOR::getConstraintPanel( wxWindow* aParent, const DRC_RULE_EDITOR_CONSTRAINT_NAME& aConstraintType ) { + // Use millimeters as default unit since constraint data stores values in mm + EDA_UNITS units = EDA_UNITS::MM; + switch( aConstraintType ) { case VIA_STYLE: - return new DRC_RE_VIA_STYLE_PANEL( aParent, m_constraintTitle, - dynamic_pointer_cast( m_constraintData ) ); + return new DRC_RE_VIA_STYLE_OVERLAY_PANEL( + aParent, + dynamic_pointer_cast( m_constraintData ).get(), + units ); + case MINIMUM_TEXT_HEIGHT_AND_THICKNESS: - return new DRC_RE_MINIMUM_TEXT_HEIGHT_THICKNESS_PANEL( - aParent, m_constraintTitle, - dynamic_pointer_cast( m_constraintData ) ); + return new DRC_RE_MIN_TXT_HT_TH_OVERLAY_PANEL( + aParent, + dynamic_pointer_cast( m_constraintData ).get(), + units ); + case ROUTING_DIFF_PAIR: - return new DRC_RE_ROUTING_DIFF_PAIR_PANEL( - aParent, m_constraintTitle, - dynamic_pointer_cast( m_constraintData ) ); + return new DRC_RE_ROUTING_DIFF_PAIR_OVERLAY_PANEL( + aParent, + dynamic_pointer_cast( m_constraintData ).get(), + units ); + case ROUTING_WIDTH: - return new DRC_RE_ROUTING_WIDTH_PANEL( - aParent, m_constraintTitle, - dynamic_pointer_cast( m_constraintData ) ); + return new DRC_RE_ROUTING_WIDTH_OVERLAY_PANEL( + aParent, + dynamic_pointer_cast( m_constraintData ).get(), + units ); + case PERMITTED_LAYERS: - return new DRC_RE_PERMITTED_LAYERS_PANEL( - aParent, m_constraintTitle, - dynamic_pointer_cast( m_constraintData ) ); + return new DRC_RE_PERMITTED_LAYERS_OVERLAY_PANEL( + aParent, + dynamic_pointer_cast( m_constraintData ).get() ); + case ALLOWED_ORIENTATION: - return new DRC_RE_ALLOWED_ORIENTATION_PANEL( - aParent, m_constraintTitle, - dynamic_pointer_cast( m_constraintData ) ); + return new DRC_RE_ALLOWED_ORIENTATION_OVERLAY_PANEL( + aParent, + dynamic_pointer_cast( m_constraintData ).get() ); + case CUSTOM_RULE: return new DRC_RE_CUSTOM_RULE_PANEL( aParent, dynamic_pointer_cast( m_constraintData ) ); + case ABSOLUTE_LENGTH: - return new DRC_RE_ABSOLUTE_LENGTH_TWO_PANEL( - aParent, m_constraintTitle, - dynamic_pointer_cast( m_constraintData ) ); + return new DRC_RE_ABS_LENGTH_TWO_OVERLAY_PANEL( + aParent, + dynamic_pointer_cast( m_constraintData ).get(), + units ); + default: if( DRC_RULE_EDITOR_UTILS::IsNumericInputType( aConstraintType ) ) { - DRC_RE_NUMERIC_INPUT_CONSTRAINT_PANEL_PARAMS numericInputParams( - *m_constraintTitle, dynamic_pointer_cast( m_constraintData ), - aConstraintType, *m_constraintTitle ); - - if( aConstraintType == MINIMUM_THERMAL_RELIEF_SPOKE_COUNT || aConstraintType == MAXIMUM_VIA_COUNT ) - numericInputParams.SetInputIsCount( true ); - - return new DRC_RE_NUMERIC_INPUT_PANEL( aParent, numericInputParams ); + return new DRC_RE_NUMERIC_INPUT_OVERLAY_PANEL( + aParent, + dynamic_pointer_cast( m_constraintData ).get(), + units ); } else if( DRC_RULE_EDITOR_UTILS::IsBoolInputType( aConstraintType ) ) { - wxString customLabel; - - switch( aConstraintType ) - { - case VIAS_UNDER_SMD: customLabel = "Allow Vias under SMD Pads"; break; - default: customLabel = *m_constraintTitle; - } - - DRC_RE_BOOL_INPUT_CONSTRAINT_PANEL_PARAMS boolInputParams( - *m_constraintTitle, dynamic_pointer_cast( m_constraintData ), - aConstraintType, customLabel ); - - return new DRC_RE_BOOL_INPUT_PANEL( aParent, boolInputParams ); + return new DRC_RE_BOOL_INPUT_OVERLAY_PANEL( + aParent, + dynamic_pointer_cast( m_constraintData ).get() ); } else { diff --git a/qa/tests/pcbnew/CMakeLists.txt b/qa/tests/pcbnew/CMakeLists.txt index 94c8aa0182..aac398b45f 100644 --- a/qa/tests/pcbnew/CMakeLists.txt +++ b/qa/tests/pcbnew/CMakeLists.txt @@ -96,6 +96,7 @@ set( QA_PCBNEW_SRCS drc/test_drc_tuning_profiles.cpp drc/test_drc_creepage_issue21482.cpp drc/test_drc_rule_editor.cpp + drc/test_drc_bitmap_overlay_panel.cpp pcb_io/altium/test_altium_rule_transformer.cpp pcb_io/altium/test_altium_pcblib_import.cpp diff --git a/qa/tests/pcbnew/drc/test_drc_bitmap_overlay_panel.cpp b/qa/tests/pcbnew/drc/test_drc_bitmap_overlay_panel.cpp new file mode 100644 index 0000000000..a1f75c200e --- /dev/null +++ b/qa/tests/pcbnew/drc/test_drc_bitmap_overlay_panel.cpp @@ -0,0 +1,532 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright The KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include +#include + +#include +#include + +#include + + +/** + * Helper functions that mirror the logic from DRC_RE_BITMAP_OVERLAY_PANEL. + * These allow testing the mathematical operations without requiring wxWidgets GUI. + */ +namespace BITMAP_OVERLAY_TEST_HELPERS +{ + +/** + * Compute the scale factor from a raw content scale factor. + * Mirrors GetScaleFactor() logic from DRC_RE_BITMAP_OVERLAY_PANEL. + */ +double ComputeScaleFactor( double aRawScale ) +{ + if( aRawScale < 1.25 ) + return 1.0; + else if( aRawScale < 1.75 ) + return 1.5; + else + return 2.0; +} + + +/** + * Scale a position from 1x bitmap coordinates to display coordinates. + * Mirrors ScalePosition() logic from DRC_RE_BITMAP_OVERLAY_PANEL. + */ +wxPoint ScalePosition( int aX, int aY, double aScaleFactor ) +{ + return wxPoint( static_cast( aX * aScaleFactor ), static_cast( aY * aScaleFactor ) ); +} + + +/** + * Scale a size from 1x bitmap coordinates to display coordinates. + * Mirrors ScaleSize() logic from DRC_RE_BITMAP_OVERLAY_PANEL. + */ +wxSize ScaleSize( int aWidth, int aHeight, double aScaleFactor ) +{ + return wxSize( static_cast( aWidth * aScaleFactor ), static_cast( aHeight * aScaleFactor ) ); +} + + +/** + * Check if a field position exceeds bitmap bounds. + * Mirrors bounds check logic from PositionFields() in DRC_RE_BITMAP_OVERLAY_PANEL. + */ +bool IsOutOfBounds( const wxPoint& aScaledPos, const wxSize& aScaledSize, const wxSize& aBitmapSize ) +{ + return ( aScaledPos.x + aScaledSize.GetWidth() > aBitmapSize.GetWidth() || + aScaledPos.y + aScaledSize.GetHeight() > aBitmapSize.GetHeight() ); +} + + +/** + * Sort field positions by tab order. + * Mirrors expected keyboard navigation order. + */ +void SortByTabOrder( std::vector& aPositions ) +{ + std::sort( aPositions.begin(), aPositions.end(), + []( const DRC_RE_FIELD_POSITION& a, const DRC_RE_FIELD_POSITION& b ) + { + return a.tabOrder < b.tabOrder; + } ); +} + +} // namespace BITMAP_OVERLAY_TEST_HELPERS + + +BOOST_AUTO_TEST_SUITE( DrcBitmapOverlayPanel ) + + +// ============================================================================ +// T025: ScalePosition Tests +// ============================================================================ + +BOOST_AUTO_TEST_CASE( ScalePosition_1x ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + double scale = 1.0; + + // Test various positions at 1x scale + wxPoint result1 = ScalePosition( 0, 0, scale ); + BOOST_CHECK_EQUAL( result1.x, 0 ); + BOOST_CHECK_EQUAL( result1.y, 0 ); + + wxPoint result2 = ScalePosition( 100, 50, scale ); + BOOST_CHECK_EQUAL( result2.x, 100 ); + BOOST_CHECK_EQUAL( result2.y, 50 ); + + wxPoint result3 = ScalePosition( 256, 128, scale ); + BOOST_CHECK_EQUAL( result3.x, 256 ); + BOOST_CHECK_EQUAL( result3.y, 128 ); + + // Test edge case with odd numbers + wxPoint result4 = ScalePosition( 127, 63, scale ); + BOOST_CHECK_EQUAL( result4.x, 127 ); + BOOST_CHECK_EQUAL( result4.y, 63 ); +} + + +BOOST_AUTO_TEST_CASE( ScalePosition_1_5x ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + double scale = 1.5; + + // Test various positions at 1.5x scale + wxPoint result1 = ScalePosition( 0, 0, scale ); + BOOST_CHECK_EQUAL( result1.x, 0 ); + BOOST_CHECK_EQUAL( result1.y, 0 ); + + wxPoint result2 = ScalePosition( 100, 50, scale ); + BOOST_CHECK_EQUAL( result2.x, 150 ); + BOOST_CHECK_EQUAL( result2.y, 75 ); + + wxPoint result3 = ScalePosition( 200, 100, scale ); + BOOST_CHECK_EQUAL( result3.x, 300 ); + BOOST_CHECK_EQUAL( result3.y, 150 ); + + // Test truncation behavior with odd numbers + wxPoint result4 = ScalePosition( 127, 63, scale ); + BOOST_CHECK_EQUAL( result4.x, static_cast( 127 * 1.5 ) ); // 190 + BOOST_CHECK_EQUAL( result4.y, static_cast( 63 * 1.5 ) ); // 94 +} + + +BOOST_AUTO_TEST_CASE( ScalePosition_2x ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + double scale = 2.0; + + // Test various positions at 2x scale + wxPoint result1 = ScalePosition( 0, 0, scale ); + BOOST_CHECK_EQUAL( result1.x, 0 ); + BOOST_CHECK_EQUAL( result1.y, 0 ); + + wxPoint result2 = ScalePosition( 100, 50, scale ); + BOOST_CHECK_EQUAL( result2.x, 200 ); + BOOST_CHECK_EQUAL( result2.y, 100 ); + + wxPoint result3 = ScalePosition( 256, 128, scale ); + BOOST_CHECK_EQUAL( result3.x, 512 ); + BOOST_CHECK_EQUAL( result3.y, 256 ); + + // Test that coordinates double exactly + wxPoint result4 = ScalePosition( 127, 63, scale ); + BOOST_CHECK_EQUAL( result4.x, 254 ); + BOOST_CHECK_EQUAL( result4.y, 126 ); +} + + +BOOST_AUTO_TEST_CASE( ScaleSize_AllFactors ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + // Test size scaling at all three scale factors + int width = 80; + int height = 24; + + wxSize size1x = ScaleSize( width, height, 1.0 ); + BOOST_CHECK_EQUAL( size1x.GetWidth(), 80 ); + BOOST_CHECK_EQUAL( size1x.GetHeight(), 24 ); + + wxSize size1_5x = ScaleSize( width, height, 1.5 ); + BOOST_CHECK_EQUAL( size1_5x.GetWidth(), 120 ); + BOOST_CHECK_EQUAL( size1_5x.GetHeight(), 36 ); + + wxSize size2x = ScaleSize( width, height, 2.0 ); + BOOST_CHECK_EQUAL( size2x.GetWidth(), 160 ); + BOOST_CHECK_EQUAL( size2x.GetHeight(), 48 ); +} + + +// ============================================================================ +// T026: GetScaleFactor Tests +// ============================================================================ + +BOOST_AUTO_TEST_CASE( GetScaleFactor_Returns1x_ForLowDPI ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + // Values below 1.25 should return 1.0 + BOOST_CHECK_EQUAL( ComputeScaleFactor( 1.0 ), 1.0 ); + BOOST_CHECK_EQUAL( ComputeScaleFactor( 1.1 ), 1.0 ); + BOOST_CHECK_EQUAL( ComputeScaleFactor( 1.24 ), 1.0 ); + BOOST_CHECK_EQUAL( ComputeScaleFactor( 1.249 ), 1.0 ); + + // Edge case at boundary (1.25 should NOT return 1.0) + BOOST_CHECK( ComputeScaleFactor( 1.25 ) != 1.0 ); +} + + +BOOST_AUTO_TEST_CASE( GetScaleFactor_Returns1_5x_ForMediumDPI ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + // Values at or above 1.25 but below 1.75 should return 1.5 + BOOST_CHECK_EQUAL( ComputeScaleFactor( 1.25 ), 1.5 ); + BOOST_CHECK_EQUAL( ComputeScaleFactor( 1.5 ), 1.5 ); + BOOST_CHECK_EQUAL( ComputeScaleFactor( 1.74 ), 1.5 ); + BOOST_CHECK_EQUAL( ComputeScaleFactor( 1.749 ), 1.5 ); + + // Edge case at boundary (1.75 should NOT return 1.5) + BOOST_CHECK( ComputeScaleFactor( 1.75 ) != 1.5 ); +} + + +BOOST_AUTO_TEST_CASE( GetScaleFactor_Returns2x_ForHighDPI ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + // Values at or above 1.75 should return 2.0 + BOOST_CHECK_EQUAL( ComputeScaleFactor( 1.75 ), 2.0 ); + BOOST_CHECK_EQUAL( ComputeScaleFactor( 2.0 ), 2.0 ); + BOOST_CHECK_EQUAL( ComputeScaleFactor( 2.5 ), 2.0 ); + BOOST_CHECK_EQUAL( ComputeScaleFactor( 3.0 ), 2.0 ); +} + + +BOOST_AUTO_TEST_CASE( GetScaleFactor_BoundaryValues ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + // Test exact boundary values + BOOST_CHECK_EQUAL( ComputeScaleFactor( 1.24999 ), 1.0 ); + BOOST_CHECK_EQUAL( ComputeScaleFactor( 1.25 ), 1.5 ); + BOOST_CHECK_EQUAL( ComputeScaleFactor( 1.74999 ), 1.5 ); + BOOST_CHECK_EQUAL( ComputeScaleFactor( 1.75 ), 2.0 ); +} + + +// ============================================================================ +// T027: Tab Order Sorting Tests +// ============================================================================ + +BOOST_AUTO_TEST_CASE( TabOrderSorting_AlreadySorted ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + std::vector fields = { + { 10, 50, 20, 1 }, // tabOrder = 1 + { 60, 100, 20, 2 }, // tabOrder = 2 + { 110, 150, 20, 3 } // tabOrder = 3 + }; + + SortByTabOrder( fields ); + + BOOST_CHECK_EQUAL( fields[0].tabOrder, 1 ); + BOOST_CHECK_EQUAL( fields[1].tabOrder, 2 ); + BOOST_CHECK_EQUAL( fields[2].tabOrder, 3 ); +} + + +BOOST_AUTO_TEST_CASE( TabOrderSorting_ReversedOrder ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + std::vector fields = { + { 10, 50, 20, 3 }, // tabOrder = 3 + { 60, 100, 20, 2 }, // tabOrder = 2 + { 110, 150, 20, 1 } // tabOrder = 1 + }; + + SortByTabOrder( fields ); + + BOOST_CHECK_EQUAL( fields[0].tabOrder, 1 ); + BOOST_CHECK_EQUAL( fields[1].tabOrder, 2 ); + BOOST_CHECK_EQUAL( fields[2].tabOrder, 3 ); + + // Verify the associated coordinates moved with the tab order + BOOST_CHECK_EQUAL( fields[0].xStart, 110 ); // Was originally tabOrder 1 + BOOST_CHECK_EQUAL( fields[1].xStart, 60 ); // Was originally tabOrder 2 + BOOST_CHECK_EQUAL( fields[2].xStart, 10 ); // Was originally tabOrder 3 +} + + +BOOST_AUTO_TEST_CASE( TabOrderSorting_MixedOrder ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + std::vector fields = { + { 10, 50, 20, 5 }, + { 60, 100, 40, 1 }, + { 110, 150, 60, 3 }, + { 160, 200, 80, 2 }, + { 210, 250, 100, 4 } + }; + + SortByTabOrder( fields ); + + BOOST_CHECK_EQUAL( fields[0].tabOrder, 1 ); + BOOST_CHECK_EQUAL( fields[1].tabOrder, 2 ); + BOOST_CHECK_EQUAL( fields[2].tabOrder, 3 ); + BOOST_CHECK_EQUAL( fields[3].tabOrder, 4 ); + BOOST_CHECK_EQUAL( fields[4].tabOrder, 5 ); +} + + +BOOST_AUTO_TEST_CASE( TabOrderSorting_DuplicateOrders ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + // Duplicate tab orders should maintain relative position (stable sort behavior) + std::vector fields = { + { 10, 50, 20, 2 }, + { 60, 100, 40, 1 }, + { 110, 150, 60, 2 }, // Duplicate tabOrder = 2 + { 160, 200, 80, 1 } // Duplicate tabOrder = 1 + }; + + SortByTabOrder( fields ); + + // All tabOrder 1 fields should come before tabOrder 2 fields + BOOST_CHECK_EQUAL( fields[0].tabOrder, 1 ); + BOOST_CHECK_EQUAL( fields[1].tabOrder, 1 ); + BOOST_CHECK_EQUAL( fields[2].tabOrder, 2 ); + BOOST_CHECK_EQUAL( fields[3].tabOrder, 2 ); +} + + +BOOST_AUTO_TEST_CASE( TabOrderSorting_SingleField ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + std::vector fields = { { 10, 50, 20, 1 } }; + + SortByTabOrder( fields ); + + BOOST_CHECK_EQUAL( fields.size(), 1 ); + BOOST_CHECK_EQUAL( fields[0].tabOrder, 1 ); +} + + +BOOST_AUTO_TEST_CASE( TabOrderSorting_EmptyVector ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + std::vector fields; + + SortByTabOrder( fields ); + + BOOST_CHECK( fields.empty() ); +} + + +// ============================================================================ +// T028: Bounds Warning Tests +// ============================================================================ + +BOOST_AUTO_TEST_CASE( BoundsWarning_WithinBounds ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + wxSize bitmapSize( 300, 200 ); + + // Field completely within bounds + wxPoint pos1( 10, 10 ); + wxSize size1( 80, 24 ); + BOOST_CHECK( !IsOutOfBounds( pos1, size1, bitmapSize ) ); + + // Field at edge of bounds (exactly fitting) + wxPoint pos2( 220, 176 ); + wxSize size2( 80, 24 ); + BOOST_CHECK( !IsOutOfBounds( pos2, size2, bitmapSize ) ); + + // Field at origin + wxPoint pos3( 0, 0 ); + wxSize size3( 100, 50 ); + BOOST_CHECK( !IsOutOfBounds( pos3, size3, bitmapSize ) ); +} + + +BOOST_AUTO_TEST_CASE( BoundsWarning_ExceedsWidth ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + wxSize bitmapSize( 300, 200 ); + + // Field exceeds right edge + wxPoint pos( 250, 10 ); + wxSize size( 80, 24 ); + + BOOST_CHECK( IsOutOfBounds( pos, size, bitmapSize ) ); +} + + +BOOST_AUTO_TEST_CASE( BoundsWarning_ExceedsHeight ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + wxSize bitmapSize( 300, 200 ); + + // Field exceeds bottom edge + wxPoint pos( 10, 180 ); + wxSize size( 80, 30 ); + + BOOST_CHECK( IsOutOfBounds( pos, size, bitmapSize ) ); +} + + +BOOST_AUTO_TEST_CASE( BoundsWarning_ExceedsBothDimensions ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + wxSize bitmapSize( 300, 200 ); + + // Field exceeds both edges + wxPoint pos( 250, 180 ); + wxSize size( 80, 30 ); + + BOOST_CHECK( IsOutOfBounds( pos, size, bitmapSize ) ); +} + + +BOOST_AUTO_TEST_CASE( BoundsWarning_FieldLargerThanBitmap ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + wxSize bitmapSize( 300, 200 ); + + // Field larger than entire bitmap + wxPoint pos( 0, 0 ); + wxSize size( 400, 300 ); + + BOOST_CHECK( IsOutOfBounds( pos, size, bitmapSize ) ); +} + + +BOOST_AUTO_TEST_CASE( BoundsWarning_AtScaledPositions ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + // Simulate a field at 1x coordinates that fits, but may not fit when scaled + int baseX = 250; + int baseY = 180; + int baseWidth = 40; + int baseHeight = 15; + + // At 1x, bitmap is 300x200 + wxSize bitmap1x( 300, 200 ); + wxPoint pos1x = ScalePosition( baseX, baseY, 1.0 ); + wxSize size1x = ScaleSize( baseWidth, baseHeight, 1.0 ); + BOOST_CHECK( !IsOutOfBounds( pos1x, size1x, bitmap1x ) ); + + // At 1.5x, bitmap becomes 450x300 + wxSize bitmap1_5x( 450, 300 ); + wxPoint pos1_5x = ScalePosition( baseX, baseY, 1.5 ); + wxSize size1_5x = ScaleSize( baseWidth, baseHeight, 1.5 ); + BOOST_CHECK( !IsOutOfBounds( pos1_5x, size1_5x, bitmap1_5x ) ); + + // At 2x, bitmap becomes 600x400 + wxSize bitmap2x( 600, 400 ); + wxPoint pos2x = ScalePosition( baseX, baseY, 2.0 ); + wxSize size2x = ScaleSize( baseWidth, baseHeight, 2.0 ); + BOOST_CHECK( !IsOutOfBounds( pos2x, size2x, bitmap2x ) ); +} + + +BOOST_AUTO_TEST_CASE( BoundsWarning_EdgeCases ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + wxSize bitmapSize( 300, 200 ); + + // Field exactly at boundary (should be within bounds) + wxPoint posExact( 220, 176 ); + wxSize sizeExact( 80, 24 ); + BOOST_CHECK( !IsOutOfBounds( posExact, sizeExact, bitmapSize ) ); + + // Field 1 pixel over width + wxPoint posOverWidth( 221, 176 ); + BOOST_CHECK( IsOutOfBounds( posOverWidth, sizeExact, bitmapSize ) ); + + // Field 1 pixel over height + wxPoint posOverHeight( 220, 177 ); + BOOST_CHECK( IsOutOfBounds( posOverHeight, sizeExact, bitmapSize ) ); +} + + +BOOST_AUTO_TEST_CASE( BoundsWarning_ZeroSizedField ) +{ + using namespace BITMAP_OVERLAY_TEST_HELPERS; + + wxSize bitmapSize( 300, 200 ); + + // Zero-sized field should never be out of bounds + wxPoint pos( 0, 0 ); + wxSize zeroSize( 0, 0 ); + BOOST_CHECK( !IsOutOfBounds( pos, zeroSize, bitmapSize ) ); + + // Zero-sized field at edge + wxPoint posEdge( 300, 200 ); + BOOST_CHECK( !IsOutOfBounds( posEdge, zeroSize, bitmapSize ) ); +} + + +BOOST_AUTO_TEST_SUITE_END() diff --git a/resources/bitmaps_png/CMakeLists.txt b/resources/bitmaps_png/CMakeLists.txt index 6bc5085dbc..e00cb915e5 100644 --- a/resources/bitmaps_png/CMakeLists.txt +++ b/resources/bitmaps_png/CMakeLists.txt @@ -714,6 +714,48 @@ set( BMAPS_256 tune_diff_pair_skew_legend ) +# Constraint bitmaps with light/dark theme variants (for DRC rule editor panels) +# These are in sources/light/constraints/ and sources/dark/constraints/ +set( BMAPS_CONSTRAINTS + absolute-length-2 + allowed-orientation + basic-clearance + board-outline-clearance + clearance + copper_to_edge_clearance + copper-to-hole-clearance + creepage-distance + hole-size + hole-to-hole-clearance + hole-to-hole-distance + length + matched-length-diff-pair + maximum-allowed-deviation + maximum-via-count + minimum-angular-ring + minimum-annular-width + minimum-clearance + minimum-connection-width + minimum-item-clearance + minimum-soldermask-silver + minimum-text-height-and-thickness + minimum_thermal_relief_spoke_count + minimum-through-hole + minimum-track-width + minimum-uvia-diameter + minimum-uvia-hole + minimum-via-diameter + permitted-layers + routing-diff-pair + routing-width + silk_clearance + silk-to-soldermask-clearance + soldermask-expansion + solderpaste-expansion + via-style + vias-under-smd + ) + # Images in this section are generated at whatever resolution is set in the source SVG file # Use Inkscape Document Properties > Custom Size to set (make sure units are pixels) # These are used for images in the UI that are not-square or very large (infographics, etc) @@ -944,6 +986,64 @@ function( bitmap_dir pngWidth pngHeight bmapList ) endfunction() +# Function bitmap_dir_constraints +# Like bitmap_dir but looks for SVGs in sources/${theme}/constraints/ subdirectory. +# Used for DRC rule editor constraint overlay panel images that need light/dark variants. +# Transforms hyphens to underscores in output names to match BITMAPS enum naming convention. +function( bitmap_dir_constraints pngWidth pngHeight bmapList ) + + set( pngDir "${CMAKE_CURRENT_SOURCE_DIR}/png" ) + + file( MAKE_DIRECTORY ${pngDir} ) + file( MAKE_DIRECTORY ${TMP_DIR} ) + + foreach( theme ${THEMES} ) + + if( NOT ${theme} STREQUAL "light" ) + set( themeTag "_${theme}" ) + else() + set( themeTag "" ) + endif() + + if( ${pngHeight} EQUAL -1 ) + set( heightTag "" ) + else() + set( heightTag "_${pngHeight}" ) + endif() + + foreach( bmn ${bmapList} ) + + # Transform hyphens to underscores for the output name to match BITMAPS enum + string( REPLACE "-" "_" bmnNormalized "${bmn}" ) + + set( svgFile "${CMAKE_CURRENT_SOURCE_DIR}/sources/${theme}/constraints/${bmn}.svg" ) + set( pngFile "constraint_${bmnNormalized}${themeTag}${heightTag}.png" ) + set( pngPath "${pngDir}/${pngFile}" ) + set( tmpFile "${TMP_DIR}/${pngFile}" ) + + if( NOT EXISTS ${svgFile} ) + message( "Warning: Source SVG ${svgFile} does not exist!" ) + continue() + endif() + + svg2png( ${svgFile} ${tmpFile} ${pngWidth} ${pngHeight} ) + png2png( ${tmpFile} ${pngPath} ) + + set( bitmapInfo + " aBitmapInfoCache[BITMAPS::constraint_${bmnNormalized}].emplace_back( BITMAPS::constraint_${bmnNormalized}, wxT( \"${pngFile}\" ), ${pngHeight}, wxT( \"${theme}\" ) );\n" + ) + + set( BITMAP_INFO_LIST "${BITMAP_INFO_LIST}${bitmapInfo}" ) + list( APPEND ALL_PNGS ${pngPath} ) + endforeach() + endforeach() + + set( ALL_PNGS ${ALL_PNGS} PARENT_SCOPE ) + set( BITMAP_INFO_LIST ${BITMAP_INFO_LIST} PARENT_SCOPE ) + +endfunction() + + include( FindUnixCommands ) if( TAR STREQUAL "TAR-NOTFOUND" ) @@ -1070,6 +1170,9 @@ if( MAINTAIN_PNGS ) bitmap_dir( -1 -1 "${BMAPS_OTHER}" ) + # Constraint bitmaps with light/dark theme variants (DRC rule editor panels) + bitmap_dir_constraints( -1 -1 "${BMAPS_CONSTRAINTS}" ) + configure_file( ${BITMAP_INFO_TEMPLATE} ${BITMAP_INFO_FILE} NEWLINE_STYLE UNIX ) add_custom_target( generate_pngs ALL diff --git a/resources/bitmaps_png/generate_themed_constraints.py b/resources/bitmaps_png/generate_themed_constraints.py new file mode 100644 index 0000000000..b73dedbcc3 --- /dev/null +++ b/resources/bitmaps_png/generate_themed_constraints.py @@ -0,0 +1,120 @@ +#!/usr/bin/env python3 +""" +Generate themed (light/dark) versions of constraint SVGs for KiCad DRC Rule Editor. + +Color palette from https://dev-docs.kicad.org/en/rules-guidelines/icon-design/ +""" + +import os +import re +import shutil +from pathlib import Path + +# Color transformations from light to dark theme (case-insensitive) +LIGHT_TO_DARK_COLORS = { + '#545454': '#ded3dd', # Primary Gray stroke + '#606060': '#606060', # Dense fills - stays same + '#b9b9b9': '#e0e0e0', # Accent Grey + '#1a81c4': '#42b8eb', # Primary Blue + '#39b4ea': '#1a81c4', # Accent Blue (swap) + '#bf2641': '#f2647e', # Primary Red + '#f3f3f3': '#545454', # Area Fill + '#dcdcdc': '#545454', # Light boundary lines + '#000000': '#ded3dd', # Black strokes become light + '#000fe5': '#42b8eb', # Blue arrows +} + +# Files to process - mapping from source name to output name +# Format: 'source_filename.svg': 'output-name.svg' +CONSTRAINT_FILES = { + # Specialized panels + 'absolute-lenght-2.svg': 'absolute-length-2.svg', + 'allowed-orientation.svg': 'allowed-orientation.svg', + 'vias-under-SMD.svg': 'vias-under-smd.svg', + 'minimum_text_height_and_thickness.svg': 'minimum-text-height-and-thickness.svg', + 'permitted-layers.svg': 'permitted-layers.svg', + 'via-style.svg': 'via-style.svg', + + # Numeric input constraints + 'Basic clearance.svg': 'basic-clearance.svg', + 'board-outline-clearance.svg': 'board-outline-clearance.svg', + 'minimum_clearance.svg': 'minimum-clearance.svg', + 'minimum_item_clearance.svg': 'minimum-item-clearance.svg', + 'minimum_connection_width.svg': 'minimum-connection-width.svg', + 'minimum_track_width.svg': 'minimum-track-width.svg', + 'copper_to_hole_clearance.svg': 'copper-to-hole-clearance.svg', + 'hole_to_hole_clearance.svg': 'hole-to-hole-clearance.svg', + 'minimum_annular_width.svg': 'minimum-annular-width.svg', + 'minimum_through_hole.svg': 'minimum-through-hole.svg', + 'hole-to-hole-distance.svg': 'hole-to-hole-distance.svg', + 'minimum_uvia_hole.svg': 'minimum-uvia-hole.svg', + 'minimum_uvia_diameter.svg': 'minimum-uvia-diameter.svg', + 'minimum_via_diameter.svg': 'minimum-via-diameter.svg', + 'silk-to-soldermask-clearance.svg': 'silk-to-soldermask-clearance.svg', + 'minimum-soldermask-silver.svg': 'minimum-soldermask-silver.svg', + 'solderpaste-expansion.svg': 'solderpaste-expansion.svg', + 'maximum_allowed_deviation.svg': 'maximum-allowed-deviation.svg', + 'minimum-angular-ring.svg': 'minimum-angular-ring.svg', + 'matched-lenght-diff-pair.svg': 'matched-length-diff-pair.svg', +} + + +def transform_colors_to_dark(svg_content: str) -> str: + """Transform light theme colors to dark theme colors.""" + result = svg_content + + for light_color, dark_color in LIGHT_TO_DARK_COLORS.items(): + # Case-insensitive replacement for hex colors + pattern = re.compile(re.escape(light_color), re.IGNORECASE) + result = pattern.sub(dark_color, result) + + return result + + +def process_svg_files(): + """Process all constraint SVGs and create themed versions.""" + script_dir = Path(__file__).parent + source_dir = script_dir / 'sources' / 'constraints' + light_dir = script_dir / 'sources' / 'light' / 'constraints' + dark_dir = script_dir / 'sources' / 'dark' / 'constraints' + + # Create output directories if they don't exist + light_dir.mkdir(parents=True, exist_ok=True) + dark_dir.mkdir(parents=True, exist_ok=True) + + processed = 0 + skipped = 0 + + for source_name, output_name in CONSTRAINT_FILES.items(): + source_path = source_dir / source_name + + if not source_path.exists(): + print(f"WARNING: Source file not found: {source_name}") + skipped += 1 + continue + + # Read source SVG + with open(source_path, 'r', encoding='utf-8') as f: + svg_content = f.read() + + # Write light version (copy as-is, since originals use light theme colors) + light_path = light_dir / output_name + with open(light_path, 'w', encoding='utf-8') as f: + f.write(svg_content) + print(f"Created light: {output_name}") + + # Transform and write dark version + dark_content = transform_colors_to_dark(svg_content) + dark_path = dark_dir / output_name + with open(dark_path, 'w', encoding='utf-8') as f: + f.write(dark_content) + print(f"Created dark: {output_name}") + + processed += 1 + + print(f"\nProcessed {processed} files, skipped {skipped}") + return processed, skipped + + +if __name__ == '__main__': + process_svg_files() diff --git a/resources/bitmaps_png/png/constraint_absolute_length_2.png b/resources/bitmaps_png/png/constraint_absolute_length_2.png new file mode 100644 index 0000000000000000000000000000000000000000..52add574232195dae505d2210862c157784b0021 GIT binary patch literal 1951 zcmcIldo+}382`R8!^fn)F>WC~Y-bZ0$x^7ktTCeo9j6;s6DF~_G!a7MOQYnHY13{l zWl^dV$z8dHuQ5a&_T+w9GcMa&B+6xEcd}E+0BwzR=7<@A;tO2q~wvyskgV zp|*BH;eH*72(Gt91`4uprNa`xFn9FcK2)5x%uF8&rsvLfbyiI=#%eJ$I@seQmjy2h zeObL430d7lzP~baX&kjE?#jJ7?!hPwuU6%DWXp>Z(yWB&>3<( zBMm_=>}tp!X;dZgpU98Y$4I;qAQ5iDG-K~UO_;5RVVJBkt473QiL+{85mFybm(ic+ z5ZtN@#gi1rj0xsD$0VX&yXu-^&7nY==oM-2lb`Z$Z(ZJzJnH)P?9zw3Nx~Mp=pQos z6h+ZG#a{Y|nn&QXj0cHD#WfTq(W%>l{5$c{J|%hulZ%me)usm)&2Clr>mvsjHs9Ji zQ@Q+`@N1;;y20r!$+IUcrS0+@>HNuph%HXja+WkAr*zuZbazlARY0NRzHCQS*B&2> z!;+@DzfWm%Mjg~CO>SzW+rMrngX`N#v!zdY8iJOBjqL8Z2Z|y+^2|f>1SArug?mg^ zv@43Bp}11-<~+6&suaV6Y27$1(06xBnkI2r;l5>JjSSuy(9JVxM}{WBymdlPs>4@F49MQO1yq4G)4R$#spBmMK4O%%0B*LVHVfpR4vmLIh{bp1Bk8MpffFX-lIj1x^XcTEQYRrQ5~B+$kuYmYOcc7VPdP zq~u3us}jVQzwH@WXg{3tmnjyvo5$&W9B1dKAQbnClZ(?vi02WcStWY$7FI0wM z?QE_b5qI#*(flvPdE`_e(=EqP6-LpP52G&qnU{UTc4|F85x^%9AZ8C18l`n}UwbvT z#bFbIVX0*1wz>?Sr^^eCn4r~1OKbj7UZsQg-;6SIm}g-V_ke3*6DVVj5#)-SVnUO2cQ~J8EZR0HGro?IhWw0OQEUlt<=_BR*@G`1MAi@<#>jP4?cOdB2VSfB;!>1kQP0;5I5E392Xv56}1TZuIBEs2}64hV?*4n@(tk8L&2!{%<$ zE&I+Irr+%Im|oF+a=yOuJjQyHH|CWfQDQ1J8Nc=%axqe!cSUuh6f(JTAlGKIjpUFH zH4lxhnXr6qDml(GKv+$D3JikaaEw!C&->@?B3{33!|&&&gcNlMO0AS1HL!-DHN5;X zspa4wda{e>PhYz~zo+3v1wpptY7J*LQDInfVJZHSQ7ravi q!vG8eL?Qr!C<@5piy_Q?Q6tlSEX0wbTqhg6fFs@6{-NEm*uMZk6T-d# literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_absolute_length_2_dark.png b/resources/bitmaps_png/png/constraint_absolute_length_2_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..818d83e10062059139f8704a313b8745a8cf8d1a GIT binary patch literal 1987 zcmcgtc~BEq7~fqsu-wZb%Dn>8B3O>nfRl%41$Bm{B&t zOPs4q#HqDi9UV9MTkN8%a7V{`;`?>erN>k2fz*;^JIdI)s|8X)mTJ?e9naHwXe3rv zd{{=9T)IBoHmY^HPY+UUy)N&O_qPs5AK$hK1`atP0D=GzL=XUmz1g1OpW%#_PPPGp@d(hSn)nPybVi;>o+Low3rDF>WZSfO03D zyB8behcf2^_w+nv_l0Yo)abq19;%)-5g|KBXrQE@v{QqhAX_u*uXvF&>nRDle)QSg zSP^Y~v8esr{F-G^VM4m}>)6YeOfL^$=80u`-l=^+?p0}{w8awWYy}aGl>t{Jn zZ<%y6daTmFAc3gB=Hzek;$Ufy7Tc0-TM*hnOR0dLwjOcOuJ?T|c91Njzu?4su3Dg_ zbgDL-8f>d8$s`II%7p%KN(HS>=#P?1!+ISCn)Rs~l_S#%Y%H)1mDtTB8d#1whI!$3 ztQIzks_V9};ktwHt3{Oh;~3#O9)=lM6^f9?;a_}ITntL(5A)BOCmKAR*;=<{6y6!G z!B>x{Hc2v7D3-~}tCl3|oUAb?L!5WqV&H03oSdG`VHpn+=nT*>3(d_!k2ce1Uv?FV zgp&iM?dwa~(IE&+r_IMch39Pccp8qZWO$byj#b>*?%6{O&n1_di5FdvdlWB*oO*0? z>N&=zh)f#``YZ#gFxGjat%(peL?=K_RRY(x<)33K8#W=0h1|k4+SJd4KG$-({z8~P zt_aEWh>I`<4a?`EgrCL4K~D8Ta&KkyeS2%HTH=|W-C2i{Iw7GM`*lfG_o9tC+>VJO z>Wwo&aZ>A4B6D2PpqDLzBU^^$0C8F(o%sVKLZ#W0+)`UV%j-mAVK1jEJ<~iMw zdI6j20YmZr`k2xl<9)__uUZ~|yWVQtBs|Xo%f6(hC9t%E>jEY!-W&(3)3XU)<`r*d zu$gQH*}&65&8_U#;z{Hs+=C?`czM22P~S%D+vCgi;JRl0wK}N%2D`aITl)>(_>H#Y zDW$&n(PM(Nht-x?P2dlyN`30*)jTT34+kLvQDw;_G40pARU%D@w^>#FT@EMymI+t{ z$t4k8+E1>6&{j)lEO?S}&1uqF z;)0?s_YA*(WRTm&_{x`0=VF+d?7S#e$hkJT`w^?)g~Cl*7OMmn<=K+2JXo$p#0|y# z(AxIxJIdvE8J8FD20^eWo%-gc6e!nRC)HMxxIAlON?dv?TAmSzstXCn3#>kll-mx}5L@lMkWO6L%FBPhg1HGd;ygXIP-rTJ3 zg#$PapeO*t00>gze?o6v-$nTZ$nk%hS9sH$wkd~~GFza@q=qx#>$A?gjIrh5-}M#E A1ONa4 literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_allowed_orientation.png b/resources/bitmaps_png/png/constraint_allowed_orientation.png index b7fde1c17e8f4c7b761c924271134bc54e7955bb..0b95435e0598ff65a18be9a3e09f4e5305edd3fc 100644 GIT binary patch literal 6679 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 literal 5545 zcmb_gXH=8TwoV{OASyvolusd43y4Znq=u%5^j-qerAqHbA_#&3q<4@a2nqty1qA86 zeo-Lw4$>2vzd^GVK^Pq7BVrJ(MI8Cuf0Hkd;&nGwjb(^ zkS)%fBZhY?%DBtyUKD4`j0&hT`Q?N(_4@p}-g*@t70C5r!BaI+JLZij%eNsL=(pTQ`XYZ3BYC+M*^bpbmV38yVXaM63&mdr;X(}et zFfu?6PIRi0@o%Mx;gFOUSwO&&AjlJ(=+9wf2 z@eePghktQG4teSjNHu^m7?>l;kdlEW;r_V9ZnXUI%o9xlnDB~?lC*Y7I1y1aNdZ{r zKYtR3$O3Mb}`vM(P0q7 zpPZ2`$6l1#UBj8Lja4z|kWw$R`3u7&7-c=2FCW1yX12dI$Dqg3vhOTa3QO6s#Qn7{6+IgodTEZSjuef{=K3npukjg;3n1DoD5Zzg0z`zOtUKK$fRUoLNp z6w$YMv`ttVn4e-Fz_))NsPT_FO?#}=q8J*zyRaUmS>UcRL^Qa8LW+8QM_1A>S9C;% zN8~&{K~m3tvYKe?&{Spc0+4FFN7e5nrI1)_UT&*A&il6g?H00$dceXdd8KZlP}RMC zv$R#PjtyG&sU$w3@t$pbnUQPhKDih0v%&Lo>;}))w zggZn>eX^<0KKFFY&aLuCDoaN5-o>cY_)oCaoX&WT2b_9Z%|%f=rAvj41?4#5Ev0mZ zz-=My1#T@Jy~%QWOk}e{)?94A_gq7(`Yge_#GoYa?~QEcUJpB4wCAgmtE>oUrSM*x z$8crmhL=XG{Q-PgEvjQbWqYfyhOVky8XnyQL_Jj)vHb;d z@dsX`H|*vXm$It613pp?EaK(F*`Y?p-&>$!k+=_*p`JpjE*9^2k%|Y0%s)#wDS%zR z!TE}5SLa5E*V+L>cwe}>vOImHu1iR9+?GxLTC_`zw8WJt3)5s)DBY$+XMJ3KZA#wr z9M{lH`DB;Nhi+rHZqY)(;?2;kLRU1D?^Vsp%REQw*!h_xql(m%mE(icQk=hBl9&Og z(`q3(EgVVZitev7Jr7N{Cgu}c{{94|_%;vGXAhQ~sei%?tR+uhLz6ib|E$U`7JiQZ zoU6BB2+mxN5i%9j@T($sz5o1nO6D`1u;PSC7y@LgkhUNE8}vNX_;b6GyMJU6!8a#t zWfmXJJ!E)B!{2*a|0s>WJ_QLkG})eqdit7t6|nVfbX`y{s*~UHH(CWsIbqHQRpaZL zY0zhhtgd{2oRGh6kl*G#1gYBF*)wtGf(P#Mik%UN$LIZQx|{H6Ui(d2q{E<*n-u(; zj4%xHF7&7w9ajDAtd2lN<9dNaN!_Z_COfw~pb5@p`+RTpRq5|Oq@fSm%0L(%!CI2mC<1v(@mginWs`G)`R zUg<(jQ|a+B0Nk(bh^%l|^d)-%XDoH%7kjlJ&+V{#=55!cXOFFRwfEw5AjZRx8oMpE zK6k+Gx#kzhLwvRf1UyNF#&G>j!`8R=1I3bEA}<{4Bwf+W23=|4v=(sdO7!@hXeKsw z776l5X&z^k{@mZUx_92)FY+Ty_rknX4^@@Z+~d2dd8M=vaC%#xg3N?A9*{1v}tp2F>cVt`7V9jocm%AFF)_2>40N zHY@Tvv;T=BDj~XFSq?7FL9>t;=;f4JblQL&xHqtjG66Voms;%dQsYNvg;0b~@IK7c z!1SE|)oK=CS#cD-Fq4F-=SmUY-&a>tP~v;PzCXtX3D+ain-6^6=(4Qxt=l_|QHVGh zP@q8$5(`~RPDLxpVP7xeKMqQ=cb}!s!0Ufck2coOz74O^J?HOCRy5F6_(rNrr03sh?PZRyZQbn{_>to! zR3>t9RT@q};<{&jdhlDZs!)oIn~+N%EV})A5-f%`T0}$m@68}(;Dp9~vuY(V^_@N7 z7SH3ev~N!wf=VcU=$SIaGA^FA082dO!2Xw{Pfd3) zus#@cmM35D*QFGbYL3!)oZq{~1@eX>|48|J3#+Efe(}8Dy#=-*QURbw{#7h4sOQUDQ}bJj~SEcq31l8KfZ4x5tYVy z+aHxEYr$@T+k&YA=?``V$>b(D)rPe_WL6=#UMA`)>bc z@z6vZ_~aDP>LHBn_HE^kP_J7zZ-!2=W<)X&V!p!h!wV;P)#H`h^vUl8J_F|s6O zG-!QOho!aA_x$@NRub#V2w4agW|n>c&<~P+F#i=8%)=?;V&LZF;T0H>hfm&2JEjXp zjQDpH1N8iF_4P8Z0Z%zg&!w4ov)Ki96k5foz;0P^_?77#)q&V7ys7?`GYev#8N+`q%^`*21QA0F>6Jc0%Y-I zU~5}S%h*N>o35b9AzY1S%9?O4p3JOE2}0bQsAtX=BA&~}U!vy;Zx|RZE~1YjQcoh8 z8U*e0Byo8NhWv=;{xJNZ#>8V4;D`e_C!@4FYGVpu_^xh#Zq1CF?9glZ$`@P-Y9n)8 z0CYgsWGM%F?ozwXtNf(Uynwu(VtFocfxqZ-r5x#nN#{j%ber(J1KynTIZO(F)tf_W zon7?q6`=TlAjWu6>IK~69jLc|c?B`s*??%24Ozhmq4pD-lF<`l)+9$q+R@jG~D zfXtJ3(SlBg)4MilI>VkcP(bZJWb>>c`zuwLPT5>Pq7SKn=X6d<8mN5 z5P@aS{+k8owO01eV*d)hzq=xAb+<0a9IaF8jv2Qck7FdeOtTouSFK*`iAX6r!QpX* zQI5PbOu{Mm-KEm)JiM8khIvBtCgDw3R#N&yIwYa2kBIM#QcyGiTUFC+p~4jdlWNaH z;C;3t1Y!7lPZo5$A#MERm(Ou>=0-6(CQ(xacYxgY!YY(*&JCYS~|*3RT_*>BDV!}BA#N(Ba)e_L?2>zx^xHNPULDVSy`yDtx_`%Z*>}dlj3bRp_|X zR23o$)?bt7&nya+CeO|;EK-O$Z$Bx5nfx868_p@%wLUeq%lw|yqcFa95J-57Zlu5_ zHVwxoi*iDTgSWeo_)m4zk1||_r543D*W3C-B;&aJH zb~_b&?$WqEd|OQ=B=V*D5MsQhfa_TPsxOZbj&ald6OJNv;c%)<4?~(l+*iAo93ovs zTj)Cz1q4-(ge&BRlD-(*fH1Ix%eRW7;fnB zpPDGAh_3NUqa^opSY*y{EXbaI3l!y02~fpG)VP*|8OC6w{#%)@@2B!5f<>~)bK%m7 zG3+GYfBa$*l_FW`z((h$n|cN=RKSU{euiNIet~ zv0Jgh0hX(zxBcC4$!bX81c#lqy=(`=AWWk+^Bv>4`Vu}?#Eug_{v_zuDwnNGno>%f z2WQ6K#i{AQMF_5A4dHIN zlVx}Lq$o_`i8MO*o;}hfw;<=~f1VfIoRzC7D90r|ACz6?aXj diff --git a/resources/bitmaps_png/png/constraint_allowed_orientation_dark.png b/resources/bitmaps_png/png/constraint_allowed_orientation_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..29502771af46bb39340dbbac0e2cf26d42bd9b92 GIT binary patch literal 6621 zcmbtZcTiL9mrf86P>K{0kS1UO5$PaZq)3zAiy}p85J*A`V53U!UFj_Zq!Y>~Rk{L6 z=!ofUvXuleA~Lq$Q69UMW$e>dVT#RD|e zU4aP3m?V7_#d|@xD_u;CmPsm47QIcD=opoh%v6kJu@>OhCNxWQrmIxQ%n^y+(-p*} z2a@^Pqojd0^2#H2@oCLzL!Ju_^%CO)iYo9#HmZKmb?d5D#j56)F+@|_A*rY2E$4QyPmn{&jjm(H|*m6}_d&wL%6 z+6YCdi8Oy#pLiCV+S8=B8Fn3fZOXfj!DF?w0e=Xa7C-b^RV~Ui;qeK`k+zcC@`j!I zZ|!IJ3{QW-HQ(|7`~yBmZ7?x=aYt`8%ujTQ&cOAOts{%x4XK;`Eo%;B#1Dr><_HMu z%2~iHcsa`nzR!)+i=zxw ze^aIZC?QwLYd+$O$?4Va1jAK^d+CB5w1_I(E|n^qKrvJKwo|EN4?b}a*X{pH;s1fk zzeeUC2LFKV|BCCMyZ_;VF=wI4-CO9Jw`GLe#dHcTW1ngHJE=5d3#PX#tI^)-t>z;|xbA(#kI5mIb3p zzt6)2{Xe=o{o`plCPF(YXrvnlt8- zN?ocC>}>R~NnW=BXpKXbGD%EL8wbL)t;;(-(nQ^4Hl{Nui>3)d%durpm3 zZ5YQ;q$lPF+Jak8-n(`W<8Ah?zeWOrls}(ecux^#rNu*xoevy5LO%3))l$Lv}QMiE`<%P4q|E_Q~Xhn6?XP;#`A|@sbSrSlFewPgR=HudTF5B3EyT#m+812W$oDD5dUxyEEl~XA-GXBGnt9#);7V@cp+RCPzZvYS@Yt`h z>*gY_!b4yjrRB+HP1VFKzw_mlTF-A9M5mdasjA!Cji0sI(CKHMx-qky`dw7+CD7^@ zB&Fx~D%`hNv6{mnH9uP(M+J)HmraHwSsT~MEqvt;6hG09aO;1la7kUiLe=kNeQGAo z-8$}oxy#(g^wLYBG=DO(*u>pmC23T^1=DTBdN?m7M~HFU@1@NdXYCxtDInM6iUj1u z<(%3Cs=e@@P*ct}mN6@{7yh^PokSgE zsk;FPql2yPaiYWwCaj74~_8^S>?j3=Zr9( zMhWL=%|*O~PVv%uOpBIVk?y5!>Jn>qCk$)J9H?#5lI{BdJiyawn4I3?jr-lCU=NY3 zxqeKgDT2o9Rj+A!wRhVvq<^kZXBaxtZ_`{(*vLY`k6ZKj*NnzN8mZExn61gm^Ih}L z+3fUV;ddI$Tl@63PfnfZ1V0Hee^&+bRu*M(=oB@Oy=T5E={G97jTe|ryk7P!u3iul z^JzS%UH7v{xBcqxm~31lbQm**n3G>*(Fvm-4ctRZR4g~sk1f!KY)+U(wt9KH9R?rE zui`>1-;$^++BYjK+7J&Ww$l)BS!X&SAA^3=pokAH*C(g2)E1oHt-4ZnQ+K)prLb6D zEp=Z1j3*+(p z6B^YpWqkyD_(HP0Jmrhn`k9_H%vLn2%}LfKC^Jp@Sz+AF*xd&$cU@5#4HtTCO*7Xj znODG4B+)l{`y$GxYKHJT+ERA)z4D8v%Tznr4F1lG&2a~tMZZK$x;>$;`&vE0L2Mjf zwit{A(8sHyYHl)@#a>Fx1c23S6dMi(3gDWy_8h6_!68E|rD}72`#Z*6SHi6m{3bT| zbeptJI?eB>IA83upU_roqtHJ0aF-?>2K z>Es!)%Ueu@d0bA4_qhy{t4C?sk7wjY^#^gg6RVMwPrFY94VmHPCw>9Wbm((G&Xu7Z zl3d!Qm=Vc8FZ=qn8j~KFwq%DAeBHTQd@Q=qIcf! zPxV_(Egc~dXMQiJxWS!9t=12Q`Xd9vdRvcRMagf?86t;&oNpfVHT>LZnuN6kZAc<< z@Qv2d8dT9*k)T3XxvX?2qlE)Oop`$^8c+?5_!Lk69n<>UosHTt;!#dc}`XtQT)4MqCIR%DC*kcMjfP4uMAHSBk_ z$CNV|3h*1A&eSY9NRJR#=KZ4db`gJqg)Q-3diJAN&ic!|1!N;*cF!3EEn8xP)t?tSj%S>Zx}u+KT(3}-yQWnd%f%I&U*|i@X6<&X zbm%0)lea-L_x(HJm*-cheGtI`(a$8Ud>As6-nvYG!z})Yi(Fq0TrD2H6xc+2S;M+9 z>jYnX^IB1o*14>w2&UpeN8GrM!XW1T%HvW)y>vNTk%BzEu9Q|ID7^44_?lJ?ZPmd_ zZCzE9LqU2#-cv?;Az22)MsJ+N^9$eiIgh~_#$zY=)l0YX7nX{1;6jpm^0fNU>z1$A15dE5yn1HIx^1cZMRFLfw{e+5_W z#c{#Nx@=~MvtOK6P9u+rFlQk*)SRB3{<|gCL0$szi3Ftx4%jC@J^7y z4&Gbuk33v4f75z@a5($dGrc(p1O{yc@sFEMrR}a%;=LzY_r6i0J@b4rkF(`35@9`6 z8zupp2q+(vcI9ScIw#PL2OsO!#};=&bj01LG5m(r@5r`Tue4igpM4upi)cQz+M;D) zVNnUBt$24g8#$%b6BsD7Osw7N@UvC?m37evrBfGi^cN3<{NkV+iqerTSVL^%8>@~O zRkoZv_B+OcR4;6C928-lmHU^~*xj#=v%Y6}|Lvowk|IdupkNPLa*~S{d;p%elfGw- z{M;f*y&EXYXPomZe)Pc)2;12~<;w6(a+!+Db*I^Q-{XRv6kDO3VD(Q~J7w}j&P|gp zs*yPxn)M^ra0Yr(()j2y`@J;|%!n2|m<>}>p|a-O;hkl^r7oaMa;wVD;j-8YLQU|2 z2k}?fC%OLcU{HkpI~lATz{VI0;+j~OKE@v$DRUbkZy}CK@^G_@V_*tZ? zqyTG{$P<$OLO1kp1IlO9yNA<~-9%7i{JX`rek4FcpWhkfJF+s1Bj0HI z=n%{eFmu>wBVwGx{W$PLUfOo$1PLi=Wde(6`~H!$tX#K=Gtc+5D~k>4G^C`l&mYxA zj@>doU41ol;@b4by>aAG2X$O&$2jHR{|miBEBQ_0TP=T%SEmDz>g3>%y;D zGlYO3(QBUCrt*;fEMoMtjCx&;KThmeON9Uq7aj1rPXI9SZwg#_aeGva0Z@5IMj6R3 zrZ{#nkJVgoKTN5C%ysPh)sf~6b%fRlFG`9(@e|PfJfUgl=NuWrii*5xBKCd7wp|f0 zk;7{i4i7(%C8`Ud9CW!sq))=b>^WuLC@PA(U=4}u7^4CWCYiL8Wnsci+m0Hg%(?N} z7Ife~OK2L1%5zO6u0x9;U#JBJt{QKim)%EgX`O@l16(uXh~+f#VkIAagq0o!{4pJm4xHmOoC_J-$BQ`84b{ z+4=OOYHY`F>ncSb2^SZ=rH)QC6&2NiudIT?oILXbBseKXw+9y{W(fHPtr3p-(;2)z z)V4ECP>HL1dwZL9c$7`s`KQ_|j8O~r?Y+cXp=rkDxw3yU-W;z|&X9!EB{asw8=M@e zE0%wDH2G6t6GunIa%)X9kZ@TRx`J)yiU@m(?UVw%99{PD?nfVsH15G5%Th@*=hL9X z%as=hLqnN6&U8{D`EFs;%bd!i0+sZT+bkakm@@$@J>p- zH){I2VZr_28}oDqiRqc&pWq~0tdXoWBht{JxHi81LWYwmE*iXH>GSP0e?4(R5A&vCMyq3N8Ir6V88?iR0jrt2^V=u;FVx zZ^E79Jsd<%r-(WWwZ3#wW3Y>ENcE!KizVLkD;BuFd2wETk?PRd7m+ z*MCKvmTR96ZuT8$UKY3L!C|A}P4_ZSAX%ncPqeqCtswh;%9uWryuTvv3DPxs$||`d4PCLGwMrb&U-LRYBdx9(*~qA zzEvJ_X*!IS9DOcF>@PVu2UJzh-v$85pPK5B4zPQK6`-zeO{?u`A_0N*+6V4J94d28 zpSMc5&-i@%E$KR=%fIpa$Cnsa>Ykf4Uiy92wSQW}{2eRxrn*NYP7s?BIV-z(3K8@x zGsJrNe}xGSnmOYzCQD*<#=yq>R0ip1=ZNNY3@0CCwG)b$iJf+9gk_J|>U^!WF^xum5S5+Fel4aEh06&q(=B1v$%9=j4PTRtz&`ID^YDnxey~TJaE|J7wDz1 zvOE#46*UPZO6Z(b>#7o>lC5zsihkdIhKZuzvsx1-8H1dWXfjCx4bLzN!Kk zf_8qb$ks=TZP}_NYl=DWHo6R>v9mdQON@1fKw+CxJ0#{R&WwAErHpY|IX*K^a3^e6 z_SYH@;$s;w2z*WLSqlS8%yBF1aDrx+{(~8FwNCeUY2^tGFdf~l#BO!CdDV*#Itu6B z_Ezyp4>zDE1@&bw21AbLi#WyBs-L} z$tO=H48ClA^8^A-e9J;`T#fnwDc0~~(#8uX9 zAcN3GE_>MGt`fn0SDd4!o1Ch{$1#;6OFJ~j_W5IY>kS|=CsBkblw)Qh`X_cFo`W@D z@Mi<6BUVQ_apKl!#XGZ<5!Pi!Ahec%y^cFg?)%V#)QgraJZ9BBZ^5&n_x{U)sF&Wu z5PVg?#Kz9r-m~A20kRTqhn1}MCRUqVm?s>qv|Jdryj)Kj-*Yx8K_21*hp{(djQGm= z=U6b{n3OuaKh)ZNiuaGEA#kRnvQrKcGjCYmnQt*c8MoA|&a2e5@r^EfOeCbN)uL<` zt^g(A74d2)+2x7aN_(>W@z$t^RmH}w0peagW;BTJ^r378%ZCp6XeV!fR-M_r~Ta?yATv0%E7Y zYd!O&%%RInWi4=GFUBII(!K@)db_aSeN;ezeH+Zh6-}}<+E)gs6WCaN=~Ah4CpFLJ zLd$KUKEBQp*Z@lTHd0=>$iF)SV2?g%pEFWrBoEG~rC==q|M%m3K+iQ;w#*|4MaAWP zJ_^wN!b`;KHlAQoLUnCh1#-bSJ+RFBM&e3S~%G2{iVha#ri#< z%qldzLL|46F~X?j*q^nb!_zA>L7YDu+we?$LXCMd?FjnYd*hn^fjfwHdy}1jjhTR< vWH9fVyx^p=76|10_p6Nm$GeWi{EN$zzgrLKjrjyYz~`xo&XbDA&)@zVo)>LS literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_basic_clearance.png b/resources/bitmaps_png/png/constraint_basic_clearance.png index ed539673f15cde0cd62f2490ea8337a3fec6f66e..e28abc55eb4a6d4be30af7e1ff60269cf51e36f2 100644 GIT binary patch literal 3090 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 diff --git a/resources/bitmaps_png/png/constraint_basic_clearance_dark.png b/resources/bitmaps_png/png/constraint_basic_clearance_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..24f4babccaaad18e5efa1e0348220d9d759aaf74 GIT binary patch literal 3114 zcmbtXc~p|=8mC+`owCNvX;PUnmuqEKMw%tmsH2F>l%=Jap5sRDON|*IF0(j8+6^cS zMM@2FLDO(S%dO0CHy1)hG*MA;16)D4*xYk&_ugjCx##}zobUa9&-4DC_x!%+ea`d! z_Jga#4)w3q0RX@bsH5El0ALGBVE{E%1>)O8aRmT07NK_MF5ViL<)H6ym(DdWvLpx= zaD>Btm)q3DOoY^*a#?=$dgIYn`|7qGcQD31R$qPTUtf_}>>r`GCk-0B+FjEW}dQ1v_SM}vtcGQzM{fnSy%Cp}K_Mx#oe%yLj%S$8`9iOTwzwfAQ#*m?iOh zw224Ct928cnzz^4c;z!9qAsB}>3gQ{BU-&pB%-h(EIXox;uX(I_MXw8Ji=x1tk%Ey z!B`>!HO!~}j7kf0b~>h#(@BRHccw*q2bq|Kr%&9r=<3cTQR5u3rJaO^c+qnk<};A> z^tjRnV^x|tQ)L?Uj_N-_!ey$Uy|N(a<7l{QmUt?w`*_I}QHrkY{M#GD=?y-NqjCMV zlzJ$+V!s>MV6|sDd7@ETy>A!FI;S5wq~6m3k#IO$3xcfBkCdE#ymy-f?1sIQq&c+VuHT^JNo$X62IT5uO> zKre)VD1E%B!a6I?i<8*d1JmGtb|RI=kTZ$T$wmk`;{krgUyv`ek z79x_-rh`fx){re8DPnTkU#?M6`&(2LY&8v#0rPTWQM;l{H{S;vcs~ zooU7PU(}DZUC=CK{D?%YnJEtYik3}T!i*0nn=6l7Cb^X46NdaFcJ_;3p8uls6pOPQ2OGioy zG~4MkJFaN^>7p(@C+6LvZ&q{MGGVyMv@Q@gNzPGAHeaVpw%+Pc_Yv(_m3+So*-hm< zjvr9-88g*VtL682C@HZY@U&shD=WhSpksFFPa_!c>`hynzXxExrFgoW47Rs{Z*R~+ z4WL^N$G=tYiOAiq>?@v1O(MlxF)~o2~g~^ z9y^QHcW#G0;8*FDIP)+c<8nLd80pl2awF@67C8?K$(J1dc9nD?WGQ7MeI0C7afb5eoL6H_8-oSfv+qqkWrJIhZ&;;+w18;p&`Xl+Bb4m+16DDJxyxWRD8u$ z&ZW%eIaB5=)EG-oe}Ndjht@wcEyqvv@`h=xzsjq0^j8k$jt85BX1g309E2B=+)#) zwPE=ztQ9s73qM23%kq2ai~2wmkp<(;TwPPLqp->GlFHAS!U>C;Rz)chd3iyhT5zg|StYgKQ||Zt zJgohqyofDXml6Z?U7YaPPVE@r}Ar-}ac2mDC4LZo~ZOV#L0R9u)Y$TiZ zN95-7PonJt+=z%k-1h*#Szt9fmItw&ogqK3 zHhh&I*nM$U(mRtrKt2?P(E{f{Y|Xf3BAO}V02Gat5r?A3DSD9z5?8phusg*>T9Wad zIJjAxTd+dG`&WeEYZ0!?Gu|MGKPYQq_r^YcLG!iSXtSl<{F@!;=d*EmuC(06-!n^~ z(G+7fdSKn6ZJ_)*K3{mYWxK&Oi#{j))!8~X?jrD@kv!DqBg4etyk1Q{UWmz`Lbq>& ztvkiAI~qze)8#*e9=vjV_Z?ke6hn0Qd1YWX zIq5;Tej&8%=33NPyHrZzXyP>_6k+oCE@bu3)VKk7!v|@XdRyX1jhVan)S+yc%e&*s zJ_(I+-V}c9Nr5k3Bkazm=rCvJn*tTH`t1tJpFC{EHD(F>n44-k14?O@sM$j2J)S;HA*=#!PycD5JEa zOVLcyi0^l2iG!6(twmeH)f9)Yn)-C~{mks}N#6g*yCC05Jf_+-GjUY$4*-DLyV@0h H=a>8s#;`|4 literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_board_outline_clearance.png b/resources/bitmaps_png/png/constraint_board_outline_clearance.png index b018565f54414552c74a5bea0a697c9b49263fbb..ad35f1c18cbf58ec62df66c5b703fd886e307e13 100644 GIT binary patch literal 2258 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 diff --git a/resources/bitmaps_png/png/constraint_board_outline_clearance_dark.png b/resources/bitmaps_png/png/constraint_board_outline_clearance_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..f929a6dda3a89bb9dcb36eb4d59775fca57329ab GIT binary patch literal 2321 zcmb7Gdo)}577j}KqNeCe(5f&q6jSwx3a!VT5f!&J)zWyhA$q-%M!gwQ%cEndC8UTH zcUn~{(a|EPB*tnJG#ElA2x%Ll(!`@B4HY+isNQ@3nzhc^Yp?z7-*yG(CTEKLY@$K$JINtA?_|Dpn~50Ji?+>3;I(#8C-9y?!{(fVsdGjpre> zVft$3Tn@*xu?gW9+j^1vIPzNl{^&k7K^-0~rbn^Qh~9SwM7KfkdCiI*9_nVZE0W@J z>HbJ@z3#CpcCavxT}8#TiiV7WKnQ789)c=MoqM@plw%eAjz$+b^@~zyB`IEHTY&fQ zQPmSdfV5ORJ>m#`-FP(uRQYG>THKZ0TO+;diE+P4?zLl<3#W<6#P- z@DCH2sa)Wo!Y2{O&bS$bo`@sOty>{+3^mV4jS_ZcjeT+qjG5DPE{ejPTUjqJa1 zW&7u)8+b10>-8V$HldB|3&}ugwMnq!ktAV#DD#Do4DP=B2H!w(Uf$7gzm&HPva4yN zcD45$VODqG=Z9X4)A--h=XmSjUF*krzgv}!!7R(l>m82xFTM~e^dr)5Exgi&lwM=y zi_-e@NWEu2j(B67o74X?*bND6LZ7oQ!pOY)ZYIh`8*=&H80XN>RDv2t7YK*$po`OYAUYqh$65i6ukS^O79mS!?{Ie%`Bd|VL%z;ua zEGUTdY-vxt>tpNPRQsBAfda8AHY;d8J%`qaX&|T8aGo7l%?ilICv%^g?-~EI@Q|!H zx`Hnemhq>pyVPWe5E__#g7M+TE<)3NHd^Bi@I*8F}S@>1m=MKsZpXpMm z4{MKkC(+wc@md&bhSiKyMA?*Dq#H%W3$$itVoocRz%Fbk>viNjvX!6K|_5@Mu}!uLFod@c*Sdy z)Mal|Xl&1dx-GeTcW8Q!^r zJ>KPh6};TBb2K;wH-W%Ei+}l?s@js8l7sjSen~*=fl+Xy6OKe9s?bW+3~Muj3O>wz z&uAJn#~9lq*Iu}w=7UsQ>TOhIuFEw(f*a54Cc?3&dJ`sdI@aO9uC6YF^;eYe-67y` zFwl4Q$?N{GCFYXm?FabGX>|&re;bK)GFD9%lE(kmU5kjy`y`PPWf{jfgdI4Ii)?q- zgIvZ64C@;9XR%HWMd>*dW|{(}M{znI73BC2wwH2W1LF+#?vF@JblR}>XJxqwLn1mX zFvd(_qAj?6JVB+GX~!vcd{e7VDVWtFi-P7xfYF15OePP?S*%WQE$ zXCEmmD&Ve)C)}pn+s28+<3Eyn4Qs_>TO=uuiLc+cG~c2;Zxx5e(ppJ)nW)tyFMlmp zQ6{w@M~bzSFXbh5@(6Zyh5`1Ro&tJK7{)zC>xUan8Z5CcBpsI-#7kB#^Gk>+JJ)iX z!yHPslL+I9=B<3sY}0w>SWZUFra&Jea7_xEZYAFdFZI3J9Qiiq|j8J){ab^g>Z6 zhAWUOmDO4^RL~96O5~E{(3WDnM|J3*AF}h^D)|fY{B_5g4!Zcsojw>I-`H?#0<7LlVuz2Wg^y=2-X92cGA9pmU)di*Q2yANAV9f& zCm)!}@~Qn7x0pK$ZSPC@@HP5jPcX}D=%SmC8ZXxya`1iu{+vp`c0Z-5S8rn?!N6lgmdY11_-q#Y zRsP38{*J>ix_u+acL7E930)_c^apm!N51vL0zO@zAM|(V{?D*B{4p1FB4^cQ2OgZ4 UL~p;L{M7+?dcfT&t|8a{1FoS)ng9R* literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_clearance.png b/resources/bitmaps_png/png/constraint_clearance.png new file mode 100644 index 0000000000000000000000000000000000000000..b6978ee8e063c7e08a9b7d5449e1e14f3bb6ded7 GIT binary patch literal 2764 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 literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_clearance_dark.png b/resources/bitmaps_png/png/constraint_clearance_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..b0931e38d2265ca95f9a45712bea6512ac2c9150 GIT binary patch literal 3232 zcmbVPc~sMP5|5&yoK|TOC`M~Qvxp#PxdK%rgm6f}Qi2ey8S`}U7{zj^cdd}ro6Gr!-PU({u5sHB*@ z7ytl}gqfQn0DwI>p#TmZ5L!@g^Q{2@2{g>~2m7GW#W9r6*c7gPm3rr6>mksSR_m6( z>EC=IV|F7?htO|pa)|Q#lM;92+gv~7+%Z{|4>I|Co#Em>MQzGI<;4`yw6eJn+ zV&Ns)fG#P?Q-H%bfGH5rD{8{p^9A(_rq77~9ZjvVC>f9mVw?+Qb2#hY^fbNHnx87H z1yOzlb;f68dbp+=cD2A7=QkUej7CX2h z&9FxZ99I}AN;T7=3$G-`++-d>R2wFw$87Bcqk4K5%ZlJj&h?%vDrU{BW=G-`cXNl}5%ypbG_xjG4Dr3K)eq{C;;Guhcr8mGrP zyF-|h2D%v}#+g(L9lcmz08Fl|8!xjBu6S*$ubY&6Y<~{5`X^zikgW-uLY1;njiAi) z>Uo`+odzJv6hi?yJdkuBWR!nC??Ae>~&uNBZ8Z$O$gsFDm|_Aqo8qLPEbO zlNb5I%v+<91%OOrHKv6tAp80ZhbhW#F$(y0`D@0x80b}-zLBiGTL28mm z%TeO7Iy=^$QA0L#fEiok6iFV84P-rnoM4|;6J!b}Z4o(S9CXQGY~U34-Z*hINqcHl z*oLPyI~RFn^T0ay?$VugQ{c0m2*HoCiOi+8*$6ypeRe!pm=(F%m=0A?^qe6$mz_O= zySFLDx0Tg3i}Mlc-&FYV;GOb{o;1)t!3)Ojj39*0 z=97~RTjNBwUz**~ZAILebWgQo6#wP2rBv#L=oi7ghxegaY4+VrN4pzx#yWeOWpT

QJ1E3+Mj%gXCGw z!hllp&D?$;?I^Dwy#=2>11ENUZ~HbSi(0vc42%wYh()MzEu*qp#u#c8apm(?@bI+@ z)a<2h<&*3jYGTmr=;MKSo~0YX#Vcw1?Zu(%U7%eLbt_#Z42!jRm}RZV9gS5|+lgKF zXl=+`abBX6m78}Gl04iLK7tXtu?w6o(%lR#9;*+eI%;4kirW55Q7s+5Fa&%_Z(x1m|C<{bonwxW{bqKxHzf}(*A>t!+B*>2?$o@=zldec}~o0lJ(f*@eS z69O6?+j~KUH98g@8Hpc;>Th#^H7%1aRh)57jM;i5EF>cW=C6J<6UZRn>a}@%VWl9x z)1W|oP%j*fh=g09z3ceKZ0IDa?+QXcq2Vg@c3{2XQl^7iFj<)h*O-v8bn&p5Ult>e zM~90$R=B;LNNh{702hRT?JWwyQ-f2*$%5+4$v=_G`i^MY6X_|Ze3Stqtm)MO)8x8escpZ=-6$GlU-F> zhWi!8VdMCTx3#v?+A(bujHJ=Mxj&+rF4(Uw*Pu0U> zn>5jeVCjwU+^y9B{5Fl347r@Zu$(XNTgj44>PIo?L+h%$XNZSXMq67|!RFdMW+YxJO)-7H|BfUO4kZF1HI7y7;LxzjkNPoCO;7lgwCWqlT9aE@u|41b; zh9rf5HOQTTLB{PHo{QuqtNAhB?I>u(%MFE~V=B@KKX`y8&;PJ11U9SU+}sT@^uNF=}!mETb+ zLE`Zleah17m*X808d3@91n%9Esi@%KDbesfzX}^#>@y?KD}SX`*==WKu+Vrn*lS8a zCYPv%kDD(JpJew@wQ(jZzFdGXGf`pPKFL1R$|d08FyY&1va%n=+S4p61pYLd3V~hu zgSq?sG8-raK9|3^`HSz*nSbh^2mKejpe6~4aWZ~0vngS3qq$hBQ?;}%+7oWEQZd(Z zc4e|6_EJQg75>Py|J@31FzR){!gz{ZCsAI`*IanXs+Ko)B1E|$@9{wT*uvtP*U{&S z4^ZBmjBy%^Mi;L~eUHgqh{3@+9J{O3kej`pWtsCBT^10jkyY`7v3Kh&S>-5F`6m2W=9y`0cah6Q{VEUHpR0vC9@5 z^Z1^Gu)62A^0LcKK@7>$BO5?Xqw66nzU)PcYI;F=;4=M=zFCI}BAGdi>d-&Gs0}NO zoYtuep*AtMAGG8BoCPa^n4-{)uflw|nm@FgbG#9CnE9uPkMliP!*LzDg4+Jo_}e{C zqbkZ8HW)y;k|rXv$?`~Zdp_g$fMvQ7n$n;Y*xz4!T1tha1XHb@`8iIvlighLAg~Ns zTMr>Ldx(+NXH@mMx3bMyk~YkmK|=l-YF_m4gIe@C%SZ;4wh z(bS%s14ye0=MX>YJ=aE?#*}kd(0OS29QB}^=R;xqH~C-MPQJLX{FC_qpl^6v_`pj; W(>$BvgTg-#0PK>rY3YS)5&r<+!(R6Q literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_copper_to_edge_clearance.png b/resources/bitmaps_png/png/constraint_copper_to_edge_clearance.png index bc6740aa4359b0e1ac97c93c4799901343c017e6..7fd3a4ab75417a414dd279077ee64f92f1da4dfd 100644 GIT binary patch literal 4532 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 h%KuK6U*EfnLU5HZFIqlqfKOw9vu0MN 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 IM6N<$f}ZQ{00000 literal 8708 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 M07*qoM6N<$g5@*r3IG5A literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_creepage_distance.png b/resources/bitmaps_png/png/constraint_creepage_distance.png index 4644574ffa0548e4e7ecc7783f81e5597b4cd5a0..42ca8dbaf73d7265b02fa718426922edb35aae61 100644 GIT binary patch literal 5472 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 Ht;7BW7+vmY literal 4294 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 D&TPpX diff --git a/resources/bitmaps_png/png/constraint_hole_size_dark.png b/resources/bitmaps_png/png/constraint_hole_size_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..c7a1f1422a05d22345fff81fc4e36a0ac7543b25 GIT binary patch literal 2963 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 Zu&C8JBgq~FXcSOBZZ4kARl5RD{}V^_^9uj~ literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_hole_to_hole_clearance.png b/resources/bitmaps_png/png/constraint_hole_to_hole_clearance.png index 0b655a764fcecd2f98efa0916e4c404fc39322aa..894a456d23250161dee5e4fc55f5133f720e82b5 100644 GIT binary patch literal 543 zcmV+)0^t3LP) z&?=}ajpr!QSSqyMx^r;|IrnnDn|uHB-@r6Y{AK(&(BF^JRT)ZD!|9QVcvQv7iUPT< z4JE>W4hdz48nz#Fn2AC8&2%71le}`P;C&G0xrS#uBaLfsH?KDq%rj$pzPaaf7!~TG zqdKrtU{RW5s-ex=Dmm;*8Ne!GwIo%M4;w8KitO`i zq^-)d`+y;=mSfUC^+24S(Iqd&oBB|kIQLh8bmAZIHvqRAh06*&M?OTT@viwvhwN$S zM1e4%u?LRG1eTM@G~&Y&!-W801*7(&u_?UT8*M>$dcQTAv|U%Jt(K>56&j+JRm_dS zQ{M{LteiV+0d`f#iI7!%nw=j{?4%htJG#ZrxKNxTGzvH8LL+Fl?E09-#V#BLnzjFT zRMha}<}UbkCTlV#g#d$taFJynBvTRP_XiX>g)jYX3FYewbTYZCs{mf8@a6ghf(*~d hU&Xgc3A#@w-T)re{{#H#_*(z~002ovPDHLkV1hA50}lWI literal 11880 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 r?^N$DqNPW6wmtuq$p6=J&X8DZ&dgZ diff --git a/resources/bitmaps_png/png/constraint_hole_to_hole_clearance_dark.png b/resources/bitmaps_png/png/constraint_hole_to_hole_clearance_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..d865e320e02e3d73ba886e141ce746771dfc0fdd GIT binary patch literal 549 zcmV+=0^0qFP)L+hYX{sq;+d&aWa{6Z_e+|z5nyS165V=m+|93e?N-W9FW2?jt|_3hut_@ zmEdS=L!mIB!-nF08QTwjsEI-Ot#lwsle}`R;Jpv(sf=emBxr|22tZq+XvJqn(GCl; zXUEXR@0_RcVMzjEQr91xP3U0e=IqSdh0O!Fu3Ah#K#j zpLEF9hE5oS0gXM#4>_@tOr{|hmKiPt2uc{y7rmRn>$gUeOYQnbtDTEfR4?3^Q@08k zVa+N6qp()C!W3}k4rzeh3FDEFReYMA2T$yz88P}O;z1sT*Q~AWr00000NkvXXu0mjf2NnDZ literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_hole_to_hole_distance.png b/resources/bitmaps_png/png/constraint_hole_to_hole_distance.png index a88936a9cb227073c4c4c98230543fa1177ef6fd..c05538b67fdeb8a682a575f1426406fbd5b90685 100644 GIT binary patch literal 3657 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 diff --git a/resources/bitmaps_png/png/constraint_hole_to_hole_distance_dark.png b/resources/bitmaps_png/png/constraint_hole_to_hole_distance_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..2e33570d25236994450906cac8e8ce5903fb2071 GIT binary patch literal 3700 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 WRgb=#!ay0|KUS6(EGmEUivI_{u0*f^ literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_length.png b/resources/bitmaps_png/png/constraint_length.png new file mode 100644 index 0000000000000000000000000000000000000000..81f237a6fe2aa87071027f174bd51a2f5207b37f GIT binary patch literal 2230 zcmV;n2ub&eP)$Y-MvN;85#|LEqXO%QI*l<-Wue`QI24aW5+`24#3NC=Au5OtLm4v>2_J3FZ z|B`q-UP45A$BRG&bRq&e5dl4ud_Lb*wY9Zv(j{ydA`PL})YM!fz`Lcmd|ktaA<_)G z;J!M6T)KmeLZlh=B;<{35F*W>Cn0Y&zy4TS;PraXt*WXzfDJ^XF!bczb)U~S*ZkTj zW;5v5znv-a$#a*+UGrP^j&1sM zdh*}t@pwj>yXSTz`Z6{ak;BkS{h`N(f;{nk!5$s^XxL+OqVDsg-SwC`${RlbZeW8E zIRt%_|J_psYxhu*_hWAiMav!wdy}9qmZB!|-V<+f?0zlSi5!N0Oyiap{x9-@Ms_(4 zzt9}b|8;g9>_iSiAGM_AKmqzkHjvwm?9--AJ4pV&4!cWeU?*}2da1vqBAdwVMs`6y zI>o2lz)qBF=&pt>zHB2;b<7TSqI`_#jlsHHAWwHT9_&O;j_Cf-dAUN)$WBxs(2w?q zMp`eeWg9soJ5hmLUMp?b63QiVuoD#kbmLQMxkk=zJW-yZ*UXr4O^tb*YA%s8vJ>SA zy7lwqQ|cH0o@?Zc>_iSjPo6ZQ?BVbw#%Svpc4K6>`P3WOiLwNJpqXLHmT$e-b#JJX zk)23!=;`KN2Ro7C&b*MwPNc!dR0YCXyR++HC(;PIAg;B$ga&pZ4X2VC z3=psrX$l?eL`4D}>_kNZ9qdF!0v+r`gSru|Y7i&E&l}A1@&+C3L}{V_CGV>@#l|Tq zp7X15t9fN*<$eVV9qdFYp+`*@-SXaQlE)D?&*?PoNUf@>I-sDTgPkZP^!^Ws$$RT} z@o|%N^i~Qw*oo3Y@BhG<^mXF6Tsi2vVV8eHy#@ON^6!~Llu6c4gxbvWU_8E-_+g+F zbd9mciE^28&^5$9+n6AeDAOz>w_V0A{1?V#tja>y4Leb`j?oh*<>c`;a~ii!rJ;kJ zfc_73vCt*;NUO!dQOcfm2fO+ibN8F8_KW~(_O7Fw*x&YeJQI|@jt+J`lI?U$Vg(wY{?8|aMeia?hp zto-sFpgJ|8OY3({(h52wyBg3>SpL~opgIS=JkVCH9dt(a!iQe=$S0oz)xi;cL8ef-nggFtl-`dOPI zQ?-ZA$X;ld*MdEhns>ekRL7vNK4aaU!-@hrBYWXMAM?;hJ3;CkbaxcIznN~Mr>|<7bclgA|!!G(KPu*1y z7;if7Wmhh}U~}8Sl>4-v9I{Zb7gO>p?SzBO0?RD0VAo?6mSxq|)rSBb=wR3P4RxD| zI3lmn<#r=H(DSlgev`T?D=YT{I@q%XJ!W}bKJ zjGkD!I_&j&r*bk5=%f$ysAUvymu6e9rvn}6q|XgA#&P(4GLjGHh8dufp3q;C{T^O3pp%*>BZm*-IU@x59UhNoB(E9JiKxK(8_$MqkZ(z;T>t<807*qoM6N<$ Eg2p*MyDFbGKq-GV$! z75Xv`3__AY=dhoMBUkC`I4B572HlFBDXbg^1R=?wTag=@5nvh(849aqDp`I+BW1d- zkHP^$NMPuR({({%3zJl(?(sDZ3pK~H~v~n3hd$N2;XC<>_4KB5*#>$Y=q8#8R7CCf10EIgBMOy$NM$MeoA+BosZV* z;?wqiv2OnHq@ftIanKO55qfD=@B%)1ZyNx3q&IgpoA<{fXsc_DH7Ta_3nNqYej_;x z0XafBfWDw2Jd#h-e;F$BRsLh)vYo;9=^KoBiJz0ykt>oyS4o&p+1KD;A!IZ3Io{w$ z!$BT_N~up?v_beHG&H)o1G)yQsW#vPFdXrjpDKLCIo zA^V`utY{j|f&QBb>!(v^8M<-j*tz| zJ;4Q;MxO4R9oP}d0raxUwuRY1KG4;8U`NQ-srzwPwvc0FN5~=2=XzVNu-;nBG;)mW z2s!2UTIF$nHjx86LJoj#zDq6J$T5vaD96xsl`bX<$vSe3>_d$eZ%2_uE{-Tz9>WO#*g=B!Ql|O_I5Tie(MA7IU>$b0J4_ zjW+?Y_W(P}d*~eSBXQ&^ThhDg3;T`sU9hn;{&zIi$Xm;QAS}>z{UTsTNC4;@fY*w= z_cgMdzt)jvbA{NSwOJR90Ct2N3jJuq(E=Kvv#hTfs$QCQ2Nlagj+n+HB90;%@B*nYeMi?sl)6iI-t&95r0d|DMf19eI(ap*B zCkJ+fB!bQYY{{o}-(v;}_+GJVyt1gpxz2D(#BiX8T01 z)h`$JsynbFlmxm)d#GYA%SNh59hoBZeRN=#Ct646Wa8Ot)ca%{uhCG*JmH^=19s`Y zIsY*??Fd(d&j!{reAZo~FAW4(I_SVI4D`r-U30yEV72c&UMlFo4(KRPpbz&E(`gk) z?=RcY(qS8RPcX#6pUSrmM<3vr{oU`a#hVRf(ueByv2Oobl%4dt-h1uWE%%idF0FoS z!rQxV;NS2gq<}68_IylNSOog*-eCN-S>HAXuU}K^DOl>;h%#FY`ZX(RHlKdo|JL|7 z{MSeU9oWTz-aEr->z?{qeGPEh0iEaeuN%9}f2$PGhl}0rb9O+F<_U%;uMJcKs14A0 zg>K&l-px`#$H*=a^vH$EVAsTV_kIhc*@qq-**`B_@zZ5eKnHelpqtJ3x{&~>P0)E` z-PKP?10BLFyF_~E7}*_md(GR{GvVDm zTLIM`=;jl0W8T?!ab7^j$nG5IGq*M!15z7D^m5-4sUDaCb^#uNtqk^Dw|f5%Kxz;4 z!lnN81>uK7Atz0H=-6-TsHAd7CP* zJ0JS&?_1iZtUZXgr`iR*-1k9YxqqfK3r_&MbD`hnY3(f8*3?||`Jp}Im-)8lddTG ztu#Qd26VB@_n(%)o)UU&-)_>$Uq8u5c(-8~=K?yQi;Df()7a@>d7DDpIqGmCbW7&_ z+@nm1jP!sG=mK7G*61@)=wXzyPD5qw{Cu$+&;eas?EC1&jY{K~e9fq%Za$)S^qaaX zeb3b~bq91L*ExFR>O22yEd8kNHn@dzxSBS}j&g7?22Np~@Y)#7Ug=m;T)^*=QKH!E7S R&@=!5002ovPDHLkV1kffj)DLH literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_matched_length_diff_pair.png b/resources/bitmaps_png/png/constraint_matched_length_diff_pair.png new file mode 100644 index 0000000000000000000000000000000000000000..d9cc4a58d9cbf2d665ffd31da35352d3e078a456 GIT binary patch literal 6669 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 diff --git a/resources/bitmaps_png/png/constraint_maximum_via_count_dark.png b/resources/bitmaps_png/png/constraint_maximum_via_count_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..b1923eb31cc1c9ba88adbbbdb961fadd8df6a41a GIT binary patch literal 5005 zcmcgwXHb*twhkbm0vi<-r79>WU62}zD1v~*LYERXbV3(MAP^Bn*fb*@M8qTDCKQn- zkbW4` zf#m}cmzVA}4D$O%I!;hZ+?KDR_WTtwaud_ES&nf?jC*)M{Y+%rZ2n@2om&X$@$(qM%Qmot;g1CWb>I2xD6#^IA>d zB4esP^-N_wFF@Evm=|z>n;}Z@-;A6n-~=52_|2Hf04|Vu0RLj{6Zrs%hJfGAZ>awa z^&2WT)NiQ&jPW}vH`D>R0MCC6xssMGtz`7pM%7Q*Uc3M1un(J=#Pl9|t?QneFf1nC z=BEO=Oy+?R%Up){h^<=9{8=0wVmUeHP({#)Fq668RsU%CgThzwLy6Im-re4u=jTq* z0j^3C4qY}CCfDRv3f0W5hSQH*%ZauIXfXo(Kqh?1a3%pkGSMjIx?9%;IyOd1*$tni zhlG`|G$Gbxo_7#wHhAW83vQ*W*{{RMfRltD&rxo+DOqRu(?7LM6_5k9cQt;^=Fd^txi(kxJ<0|bEd5~VR;9rt>2 z!Ln&@_YjlGY%VXiqK!A%QYn-?s%8Z#LLEC6qJy8EQd;MG{5fjaTXY#1E`}1EUMJ#x z#eJO9P@~OzVmE(GG?$i^CNC`bEo#GiA4^(%HIL<}%WQ;_*JHGMY`K?RZNbiTdx6fm zTI03gKT@{a!l@@g85gw&T z=)X|n0b`@;A>`WH+RDu(w^&l2OO-xs!(LAGHc$!Yv%QPPHgi zX~z^7zH+{Jv<0&n?7oHc65e$%kXrE!C%AY~s?{A>mCzE;2xOG)mN0%)&wiZELRQ*@w8Of}}8XKW#aKE^Tf-(Kgnu*}yGw$!y;TxXv`aG9`MmS}xmgx5$NA znmr%)DRk!8O2cOcWQ(jMdyk31f4)~78)h^FDEY)*6-*J3|61(+++W$A2QCVsRIUcB zQ#m&G?o7fjf&CS?^J?yZd@NFDN`%|optYVIk*(gK{()q0Ho0@>5V_$t^cREE|_-7F)NT9rP=C4vGnF%tK`2wd6$0j+f@0j!+T#xq16b7Ex!tH|4Kr0!cNl zF&W`@#zr@YeRC?uuiKkkYxbNd&+~S&fPCn|%s|_tH+QGr3K2*)aY5j!yaA)`=8#b* z>3yQs+xPuDG#0fc@Q*1HTy(y;JNDmx#`~Q!!8yLA^(l)RzCaq%EV8pquwYvB#vcN2K=J?3nHy`Ll0-f3(J?Obe3;%i{-RcVd}_u4S{ND|Q3US=8@N-qT$!n2 z-N=qNi+L$=gN)9jtqZ4Z?-9lyN2gSd58Y~$4Z$6zmB7Z7Cyv2dR5NQ9#8XLSBNODG zc;?#RtTsG-kV?6ww_TcK7$qYtY|xXxe|xI-!5U*GeUVNN#UeSe$%fffay_rs+C3Ix z)w;kC0ig_i`FXQuhH>R%v*uGkzK%c{9_QlG9((iBISw5z$ znQp{-9m}NTgxlEIh||X*=|)~ys;GZZeQKYiy;jv0k<+kHB$eYcn>X705!2k<+|K9> zJA};ZmsORZ9A@pf??;q1Ux;#6e-9$)#P*uWY@kf;ia((iv9ph?ynOjmhG)Uf$;k&> zhUjmE%G-h2^^3-I5lRNMeKx1-M*{)mwG5hRiCXttG>YzymX@2Eu5Wcgfni%tO|PBy z^G&%*z6%q^d&`M#5iOQ@-!?%0DlISXJa>_vkMS=2@YH5-14W7<7c`9Zwvo2VTp*6l z&hvV>BS(&mMDMRH1zt8@sBZ;}#AFAVFKI(r-#Wil{FGgB;a&rToE$$`(VCf+rEl)j zo+dpKt;1h-h-qxjZmO7+SFb*O2wu%^JnNSkt31#l$PNwAh&hRe$fYw-L2rbJUCIj1 zan2Z64dmfb)mt7|s!6S4jqA(>LTey&(X`?*%o&!sSA{O z+C5+s=5{7P0e?p>eNrAj<-0}38`3{)P;$c;f4+|wtR_(ViZ3<4c+ncQT(%|~I&RJ+ zRONAxNSUsk_=0#B@+$ngw!Hj@2+OMxqeTBT%~>ZJx0Q@YBB_+t$S9IYY+X_WYL&X@ zyBaV|i9(Ryj!iOTH9ew7!e=UoSGvVjoL;Qa=@opB=uXcwCQjnPT4}18mVw2H5T=K} z)ahA$ef<#$4D?!7JN+4E15Jt4FOsSY-QcelG|q;`RS1>xll`8WWBW&nC!^G+yY3d8 zLRo|=UUCcFp9C#I&=qT=pH-}puX)Wk3I(P{Mtm>1W;LWoAi)uoS4CKb?}Z$>)YBZ^ z2}#8j)Jm|lh>E0UoFJrcq-pWD2rpQzVX-Pk9BfsOVAI| zn5I$7pzM(`lZkmJ72wo!Wwa#N`tMhim%-Llv0cxQ0}Xb}8P@~oP3zVMPDV@@pFU1m zMsDQ<{mLY;S7`!MPvbENGG2>F&ZZMqyQ1&0J8U15e!6JW67S}b!YvgE7wH7^Avzj`<5VQ8WmT4ozTtWWK-Nf)N(%? zxeNLrdcG_uaCmt|<G10JWRB`Q>VH8m~st{prO?T}z1$$EKO<66Us@I~)gaawdt*NvSPD*k&_o%2= z&9;yGYDnuK`-ktO$L^=oJPG1vxOC%*as?;xrTu7!LKLTCuS_^MXY2JlXzFdt!Y;NA7x-tKqbBLi$Nadkd5MLlu*cA*!}rUOS&-f03^yZp5uroHk~4Q7!O{ER4@ zb?+gl;`s26fanc5TCyhY1U>#-yeQiFZ1V|{cmJEHzGQCu+D4t8xu;2TMD?D}?LAb? zKzSof$<=W}o(m19a(tw60?9z^QCJHl-^05=G5WKnGw6+T)t%ivpHy&mS?ybQ2udmObI{S#w$01=WcS*&QU9Z z`18bV?rf_AUng{ihWVDs4y)UIJUy3}mp3AUR#sM4MLSkEJkKDJjnW!1Lg?%Jd672N zmj`w{3V)=j$at%&6F;Y2>CoUdqWJqd{vV$Se`4G{W5#A*@*^yfxh3c#LON$gQZu8>dtD~*di^>M(acI6o%QFYQ#lr~*9 z2>(f^FZ8}WuUeND2(>%bPTJ;bPn@NTV~#RF;l*`%tJz0b(_C7=_hYq_(S}ChY4vM^ z7zqXpg;Yat61)79%y8j%el%haGtfX&UYv@u+|Iu1#LYb>=LzC6Y1<|;h6NM~k>rRl zny2L3qaD_pT?Y>`ysG)x$rC5UycL`3`c!J|V?9#TF*3~j+Vm)WdeBn7ucVKDZvJS< zwEZ7%BSaDQ_F12a#6B(^&xz_9NWmteW@uO`28hOLPuIC|R#Q#kK#_GQ_MUU(tRR7L zcdr>cj!$)-JCzf_K@sD;O^RMZCEatt#_OHJ?!4;N%WlS_a3Rl)rE3@&h7%H@6o6U! z^h2+>Y|>}(y1L?bBAsuHaSR-+nb`tLP`WYmy-@hH^|>`DDB-CyJ9$>SEW=Um+cyIV zR|5}T(fh<`=34>a_d@g7I-g8!bWVIt=o9ZL%ThNPv7+de|69?8h&&MZc#;QBckL>YUr#}~^XBpR-&1<)LJjlKOe(D~hi zR=yMTDyPzYOeKSAk%1}I%)+U#ag&+59(UN>x&WYLhdlGE8X?y9WD2n9^Im|Q39)&~ zN&gXwO6UY6VuZ5&{`i=n|BI`Nce%>CN{T3ZoVzU-C0eRWNMIsXMJz4Y&zMkBf%29F zL!R#fSx}pf^MU4GBd1##&=p5g7GmQcpFw(X;gaQ$9vymx-Ru5jEs@z;u9|>~Tn)8( zTg%Ka@?KRTakYm);ELb!pZiMYOGV@l{eiIkw)fYB%va5I?`pVCNMOIp>u+~yMv*)O zg2Z7B*LhFS)eMi9x5y{AJ9p{64O6(O*)5k&If3qxKvY;i6XxfBxC?F?J50SA5a>(* z5F*4~I7t@@lJ##Jf7(XWB?zS)xL8VS2eVHaghzM8cV8DYF3cn`bIREuLkfZ60F5205} z;kpN>f`%jmq{*wX@YH~(|0Z4>+w;FyTXuDk|Fhb%EA0G>hVwtEExQuTf0A-e(EtC{ iqjK|-60S@enaf#8~(#fqX8cHKGFK0Vi~9_hkG3bUd!WsMm!vC z3$ltyqD7%Ye0iiVkwRJTDthl;$Pz9+bGW5?UE1!Y3`1LV%2Kbe|H4bl%X3e0SzjL= zb#vuEU?0SaCSR~{h%RjCD`>KCf0 zZ>8<6pFdchHD|pu#V0vgxSko@y?`Te(O<0h7v{fhd!D7FYdTW~4ir1n-yLE3G zb$+!>DcHXN|E+a@k@iiDS&nbDiakq(Hh#RKe@~)PRkTf{I67FYfmr0=lBr;zG=oJR zp2`odLloUskSz>sIfN=Ac2EBHN^92uL#FMXYtiZ`TrHKa{JdiQZxwh8Y8T~qlzET} zt+DG*cOJ>d6Y4!#jzQAY^nPsJ7Y!YN1N~ao{?6@W6ZCb~cB__%VZM~q>r7=V(!)W> z{z9V2c{>q`KTYK|DJ`vl%9p8&MZULimSZ{>?& zm3$e0-tFSp=@Aq=On|@=ev?314cm?>2t>jDdeEe(oRCR8apeirIB%1uWrR8LP=a0G zT@;XmHrU*Gl^=Oaxgc46JqDw=u`mYLAiP}F_#tXNhuuqx2Q)LuSmeo?k1Xnr4!JCH z_Qcg7)szKwK?+83C7hKVI)3^7V>g44>}>Bu1}A5(wZ6cucLsJ#9~24F5*h{+jE9VA z2{OeH(2H;?y6e#9(1}OE5bw8~gp%T>ALuyMstuK7GdQ6L|2X>hgS}}3u)4d=vEHc+ z&fSb$3V@%S8{}`Z9J8B`0wt9#TS{Mj`i&iqYot;z-3zLR3Uhxp_GGqUk%PvnDbORY z(5Ovr=6NbKP^+btjMKWPn9Mle>578I40ZNnKRKYRUT9k^B&@$J7(O#C=Y720Pq`Ayqt;HJVYbuSB)uN&4Wy65 z+giio@dn;<uVGyefcyBR)N^K zg6lH{T#?Q1PKy|W`4w?$Flw{0(T7kLO)pipJ%xq`)b}ya?81B3^OenIMVM_=-C#Mj z4ytD$hSf)F3LKNv1HyBiOP-J}4(Gg45p8SV$qXz_SV9T8s_vLM5@%-A@_>`zRciRv z3N)W}e>TIjT$Bjc->p9T6Ns};;18%jH8b-fWU{=XF6Cy)Sc%8P<2n46-zczA>V}NT z=m-D9Dgl*G>d35VhpLvecjtC-y8E4>-Vawlh)^&SIADL-$>rC4aClNs!L!2nEQF)qP0z~I8z71c#)n4_i zg_H17<}nz%E?kTns8}74a(UU$zVHp`WOhd2s%VTp>D<_?ea0KCk&IpCIKL2!Jd@T+-#!&nv*7;zoKNX+-a)2 zH0XiExZ9d9*D?D8Q@!-Tj-;1zvBsnND%wL1BG2TyFesz##-XJ4wTZFkqwYB~sP zTPzZr&46!`lNmo!3_?VxQ0l#^s5#*`&M}x6jM}Y+I06cW3RR@K+Z~ZIma)i*N{7yc)mo)n&9i?dz4zLay-xjFN;90hfWJJ;k$WF=J@5lIEU0N%|>cjxypMNymb zu|-i740Zi41#VBc0{5STyQ7icwg&b;eqrl&b|HzGveS7rdkG9OgOv(bV8>6dXXXT5 zExYKpT`_m)^Ig!>I)-&V;J-lnF=tjoMmPO>R#+B1GAs*Ng7>-`C|bL~^qpTn%<%RZ z;2tnWY&4Dlu4wfmlp69^fBNtH_9TkB!Lik!rR{!p`7>w1Gp6TxW?Q=pWsdA3T#a6R zj%3w*pxodO;0*|Jn;c!d1a!ckt}EgtVCv^AN=?w9$L0TeX@>KbL@abXR*JZ2P)+1F zV>MdN`9QpcAC!{UnNxObFBJCP_z-3@5P{!$<1Yxzvb#;2SyO}O$(7V50 zC_xQvSitcbqgb;Y18MQtF-!i54Ggn&!yaB42S(t#Ak`f4XoqLjGW3#KbLdR>;In(e zI7!e2U))gP0~u+N;NV=Z1jlr2y!Uj7p^PaS4%%XCsZxyzu}%TS`uhHw(sz~2_QePn zRHP~G5^R}0@s|1PX4cxqWUcCGn}%#{_mHB!Y)FdPt$9lz&MAR_IqTz!`9`t11l*=y zO72bdgVvUthc3zt3T-xOGxu#fcZS1K%tGdDEHNXWY)WFpJXek_Gqn`5B-zE>z1K6E z9Y2exOltZ*4l>_Yd+uzboh;l%Bcqn$o#kY(}MmaYIl0iAccAh@dLB@I61} zY34+`Qj1sGVxw=@_D^FJEF;g==?2rS=lskRQ|BTQ1f9ZT--njzZ+zqk7ue6ulcwlZ z8n04|;8z8qu6LF^&CEXCB>=|r<@5NRpQps&%Cseae_v~d;-{{fbs6Sfu|wGnnA(M{ zb399;HQ1iMaM_}uw?W8TbMzNt35`*fH!mIuwjOo;qWVR^3oA_x${KQU*}tIkT`}IS z>VikoJbhMRXA86YjFd>@s2)t>T^ddpJLubk5K`-Y~QU&~^2|o}u)_q!^5iwV6iy zgyo{A%6@FL=kRFWd}%*6xACB!Z|t`mk=7hY`<;o;x$ z!A+il87CoAfFtL3x+$P~Ai5F1bM%2A3gPMs%geT^uObcp9BeveNw(krBP$EhjeZ9mbG=oTX$ge63TR z?by(XGgBX6ARWbqoGZ9_Kf3 zPca_r(zptQj}_16h$nX5WK@DBT5J8&*MfRsow-GUoyV0*LM?xU!DovwCgh*@a_3T9 zwf9Zj;O-}b+ok(Q-Gxx50VO}N{9C#`p&Sw3>D>gYdx?h8}<^Z=Xe z?h~$uIvld?rP%co%MX$gy$5>>Wt=Al%JsZdnc`Gvl+$|aKn&}NRexflS?5I*?D#1m zi)VQ(@kX+Pafn#Dl2GTSJ`jEfH~tX&1UdqBP4+s$JV}Kc4q}Sx}`(r#^q#(R;8gCqri=+$7=@*i$+$n947P_wfBn4nmpo`=Ma| zvfKZ9So@wo@AUJEybeF*B>^uvCP*41tbE`7sJ0;QM-BP3_0&386bOMCEJwlt;T|Q+ zBn@SF%am}l!o`?v=6tCODo?o_i@cOj#IJO^(o({zSj$&t(YgIhnvbNQQWUtOohI^h z=!)Aw*q&j@FEz`**0@%iHq@^TV@>J&St9#w|K@d3{#LEwkgK zS|q(lZ;ak3p1_WkaOOrIT+urz*q{^ChW?RgQ>b5bW5e@QfSU`kXW^Q|*~&AR*S` zws9QQRjMnN{kNd*`0(edmcT>fFT%T~lY3p0zpY_j9SCCtox4A^kVD9-M&;~R{0@lc zhM-tmVQ~f3H=63E_QS`o&TX+gV?pZemukW@Ap3iLt+lowmEoS0SOr@fSQ#?`FaPS8 zE+o7;Rx(+g=UQHHQ^NuhQ{%06GsEcoN?b6m59kx_Fx%2QO+OBy`Ykl%v2_?7+yn6u zS>Xyh-mdE%mb)Jj%AlFF%8kC4ul^26;d@AIJa9wcN>s;u>2;xeQrTvfjZE8XC(LvWp~JS)z4tiR@ztAtUP)*~PVs zTa!?ttZA_?!x&ML_nDdd_TKLMzUMvXoipcq{?G6C`F?-D=Q(H2Gch=`V+gni8~}hY zHo{l{z!n0XXSiXIzOdkR1AzSv4r^rqU2boKZ9Lc}Gc|*$1gH$Q?||(DFqHvjV!>Q0 zn2!OA1hA9=sEJ@X4Xh*p8WGUq!0IhPPXhE*u$BncQozRq@R4c%7|#eo3i3gl%fEs;UeppXxxL7K$Kfs_#iF)U?~5d6<%2Fc=? z3ox+1S(p_D4}FuFnUIB<&$v@o@;BFCz28=1EykL{@_ysL*`dn!MaJ?>7&<^x82Z=n z|72us2rUU2S)YI1J1hVD5sWUg!g#{W_5Q5@xQ@}e3@!Q+mBHWLQA!0Gm!pst|vBQ4g;N;@w{t>=|2eFfv zkAK&0fuDqs!Xlz#;^KSu?A<3Jx&MIF&(booatGxV6cm+|RSu~hK72&&sJe!RrnZi* zo<7FF(8$;XYif4lS8E$vJ9|e*CubK|x6>YHz0Udg`uU%~5D*v?d@QN+zTbQ`2sxXJp>a%FelyOUf%MDj}2amzF&!uc)l5uBokiSl{q_ zQ*(1mYg>EAqt32B9zS{7{j9gI|K-5otJg!rBco&EZzd+*zJ2%Z{fEh^>6zKN`Gv(L z>hcP0l}=y#xW4h}^X8YWuV1fTt8jsCoXz$4F$`U0K+Y5ZZgpdft`$;vu`Twxb&xpM za_$fZn`kwEOBE_c4P$UfBCOh#{d~#k2@W=X8|TqL*OGjtejY`nzD$G0 zhrx(p1K;2A$Z~D{kDgmP+vwO^icXZ+3Mw^gHLE|gXMHQm!UR=7{2wBFH|ttQS5Gl{ z{9#S=Tc;1CsD@WgrDd7Q9yU(J*z*d=x`$KyM$S8L(dx7^@8%{xN@$jopXM<>oVt3}1&MCM*~ zA&T`IDS7%rlXNq1zx%3P;Og@)&b%@uS=Dxfbu-ZjE0$(N@yAI)xLVoF5AGiW3DI+gls$!5XQjR|S1;H%>axt^=(- z_9HpovJ+p5_X-e#t?SE-4pUld#=~FBX}0r;iHE1p*QAhM4~SNzRi#OU4(eu^x_SOA z*`?s);h9O{JH>Gdnb&fF?_>aye3{SE9Ti2M-1W#}e6Mijn@P!p=H9-s1mv9UAAO7S zVH+hMw!=cBvk3xYUS+l_v!8XPv{zRzr|~qnydWS@4FmMhN2Y>fB~8=kIF1_EJ$SRJ zF=iW;u1-Zd6g!2e51%)1hdCG_(2ZIqm$$R5qWh1!(R_zbh1sCI3QJ*=pJvdm?{tT~ zG(^v<+^!{Wq9+zoOREDFUGq=vUtAE~Nt$2pH`8Z(_g=HQs*Kz9>NS1MItiU?$K_%J zTqOKZrQT?7;tPsHxoV2Ff}Xt=TJ*h(54+E3V!Ho$e&pVc$c*ac!iW&0$qwEI0E z`w>r3=;l?S z^W{+%@pr}LuVuULrlfK`qip~T@84J|x&RE{}P?75wY79MJqV{8P|Zz|evW5u7qif4d61>M{mt_R$`_}RKzo8pNXzzIvjA{gLF(~QpLP8Et46V%qr zSX=Hiq})gUfP}4kSQOR+9T}{7Av?b_#e(t~!cSLU9o45M0{-o*~CDwL`Kqc?w? zWEV2+U4-Lj^rlrUW?~tSZ(u(>E{tm)rMfpqKCka-G`rhGnb+?l7*#rY#~*pJ*3p zq{Qh+wDgwJ+EDLYLLWfF6nhG6=7anf4Jm8Kpvx1r=H5>H_H&lUD(o5TH)iYakVZC9kNU)U#%vy$FHwanP1U0dUI^$9SVW~~cH*9)?So3)qrYY)zHZ3R zAf1&ph%%&&_h@vDqbBlZOHNF>oOU;#SiL~SdZ{&M*_wyUm*}wD@PR1_ zPH**>+aGk=(Aue7L3-0pD(IG;8=rA)8k|!FWw^bl4M7;q`($zAY~#%^n-u)#-^}EY zc&SjFwA}SX;XymLAb6dai=lY4@Enm6tQ1k}z%!8G*sJVDzKpJUit=+c6wA(p1!=fH zP=oZhCya?{3Xbc5}Zyd(Si?7jwaoO7fed1d#GCb)PF#%$y3mQEA?o8-(8c!V;}MTt|Erwbj~hAdV> j!UQ@0-)4c;moGvvwf3wE39C`)9|bTrFvFDTIfwrPvx&iG diff --git a/resources/bitmaps_png/png/constraint_minimum_angular_ring_dark.png b/resources/bitmaps_png/png/constraint_minimum_angular_ring_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..a6483808b67188566f7b80ae309b211dd686d45b GIT binary patch literal 4473 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 JD{kI<{vRb>r-T3i literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_minimum_annular_width.png b/resources/bitmaps_png/png/constraint_minimum_annular_width.png index 3efebc9bf804be55a888ee5fd0ef1144adf0ce60..ba2ffd73b3fe7c84cce92db5cd1fbc1b12bb4d12 100644 GIT binary patch literal 463 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 D;W&pB diff --git a/resources/bitmaps_png/png/constraint_minimum_annular_width_dark.png b/resources/bitmaps_png/png/constraint_minimum_annular_width_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..163246c3ee3895ed333924d7e87382d256053017 GIT binary patch literal 459 zcmV;+0W|)JP)mjMME*aVBK99dKbtJ@ ze^IwmB{&XtzR+>p{8Ha-=L@lhhW|`(3;1&QZZf1W{71&~notct+R3mepnyRj0f<3t zWVwso3Yds7v@LFKmXDQ8* z$?+DS1<8dBLdX_8Mz!EM!F(W)E3hAL5Opyu23Z0!9K=SJJ5MNxKv=q1x{xo6ZvqVG zRDal0zC==nc1SHpA!Jt4?26c@7B-9HYhcs0FmQ007XV1B%vQ$k+e?002ovPDHLkV1nbO BzIp%v literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_minimum_clearance.png b/resources/bitmaps_png/png/constraint_minimum_clearance.png index 9d04a21403ce0986bca0a7fcb13de3364edb1ff8..3c2bdcafe284af820f05b0084a8060e41920e2ca 100644 GIT binary patch literal 409 zcmV;K0cQS*P)a)A&3o^uPWz9R!b~K;fNN99_Gm4_>T*7XLG+4EfSsN(BL3ImIZvd ze7hM^82%H&0(k<5ftIk4WC2hsBX2hE17a)yVX0E7Y?3TcsZfa~)^HH!&*NWCv<0TU zrn0~=enpA}z+hTJv;|UyQaPj;4#IL}a`8l4AXFeUffU0<@m!c~QwxJps<(i9Y#pa=$GsfPU`$dN45bWm5O;gB9koMF`} zW<)YAmY9OC6s5Q{1!lB<5{n7aN>k|)>2y+y3X)1whaLwJU`~BNv(glV)oRqd7*iN& zQ<}msZx-)unv|ySDl>;~7fni27#1rK+cBV}DLEJbPO~2m8X)1j00000NkvXXu0mjf D@S>t= literal 8443 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 Eg71~6`v3p{ literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_minimum_connection_width.png b/resources/bitmaps_png/png/constraint_minimum_connection_width.png index a112347ab40947a7e621e4044c8b13c8f6bcbb72..48ea8a0c7e209ed71cc319eceb067cf39a8d236a 100644 GIT binary patch literal 545 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 b3#fwu06!+l1_|Mm00000NkvXXu0mjf)m{M} literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_minimum_item_clearance.png b/resources/bitmaps_png/png/constraint_minimum_item_clearance.png index 650310414f66b16145c6dc5593fbfc32b1af1e91..510193346e58da705467b66f29f930cad8d85d92 100644 GIT binary patch literal 505 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
7T%Av=|o8WMT2G996C|o9ub- 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 VwnC#3v=sko>|wBIaZg0 zlXE4@BetZ1fPe{eGY;2r3QWtk*WoxE#QWRzL*xg^j{m})*%xB9W2+BLn!vBI$zj{W z4iV2n2421mjYnF(uV7s)))VEx&YhCQKYMaYV|+@F_K8UkK74RnIq$EM5%2Mqgw|Ol zw>=Xh64{fQj~r2ZBgnq7bDP78hb;0PVKcY%%C@YGljo`Bc6i9uw`X7S90i|J?gT+M zW9}(dWv4w&Wi|(8*u8NO=9ZB9XY43y*z{pRPACJzeR;{3e{R{u0KLTE>FVdQ&MBb@ E02L}NA8+O3g~qweuBKpGicJ#787Cw3X}()fy!o zD+^Lz^$}Er7L}o;MrDE!Em{$g67iA9iCtIE*{fc1 zBWJMKIQUf@7LJYv`9vz0o{54Z!;VB^u`zb$<{@!m!B}{FSO^-0LPukEkj$gtAz{&& zFpT-tBoHRp{IuC;=3N)B?gjwVbKRh4E+*a;PNY;#N&?wp>3s4MYj>l+smmB^w%lSN zAnjZj679BN@Sr8q>c=Serz19%zR-pzWZA-OQ>fv#g@r_GufN)9FMpS7i>_bCn8uhI z*LXFAM(xFF;zcNMMb!m&baDq!5wkyXNf-_1CySCC4=X0O9HbbSJhpgaZf!N!4+(g# zD6CNhEU)b+d~mme(%=*F#Py6{t=z~Ah;{va3(!a^vy7Bbd$0r>QMAM zzKJ!YCh+zT6)_$-XA@)NqU0+Bb`BAsuiPQ)v|I~BwfdIxHKQNlh1W?zunUL=!kLJk z>6;B60$+D;IwPLN&kabCOMB)ca&VU@$_CgS`Z<~f3?@XND z+eQkQofFLbJC?DwA5{7<@>C!>~YXlM`#;o;%F9Pmd} zKLMA#o?nyjv^@81FFCP7aOiJC{pKBnPU~Ii*2rGf6v1e9yX~B^tv7%;79WbJR&7R4 zZFkiqI2n_EQn`6;`d#^*4y0-QKm4<*(e1=h0r0B$;B8^P`#9<37eteiq(ycytPZjA z5?GiShoZdAqMtA2;OyeGV>7f)`1&-rE9icLoC@(n6Jdz9HZ6Cma)>}Po$aFKF~l;DfMCHInFpM{Q8q&v3PBjcik)^_6zwY`uBKb@c4+%7Na=@vL%HYh9YE{y(u5MP_jI5fo9!T5PxVG4vrhET8(3;bYajwl~z8_25SF6)1Ehu}=3B*-F+i&=)&n zxK^$?splmfEt8i!SO;!@&Pm=`u-VD$Xjyo^SkL?F_&8=_ai_0lt782S*;Q#~ySl1^B)qIk7a_Tro}D`3FS7={q@ynUdsyz>b%=>zUW@erR-<+W;3{o@d&(h0TksPyux}OS#^M?{FLE_!~8~ z-1-%1X{M#RZKVs77#B5ZxDp5)lXV00{LF%W_BGn9(4?7csvijz%v>Pe z4k`5(NzNx}Eu~_BTM;Szn&m$?jfB2Brp4d9D@VyP+ zmsY*yxw<94Q4V^R?I9z#c9<*oToEY$!uVSCvkj^9Q;?dwe{ThxOC8k z;);M5E#dp`A_(RsQQ2du&Vin(U$*6IIvrU0ozsbE!x>*dZ50EQ4~6x-j@3pZSjIQ@MDsAiv*z!*R8}7HSqbmgk=Ax4 zyeSRl?LKJ(9ySvx!3};h#6K!B3229$-5xU$p94J`R{n{Pe}}$T6Z`qlpHwG{#=6UW z7V|y2m94z@3)CQg+|9dCdXL_+_`To4Limr;>ov_!XCuLwoif>qv*z+i6t>-OHdpsA#9 zJ9bU~MUC`+7=isLMz@XWB8#Wg8Mvqr$d1hupmN${}JlohQ|&J!O7@YC8<;5%GPEzxj*}b$#$vpK5{&p-Y~S6P=f(+b>!twZ)uT5`iB9OyLZT&2ha2 zvzC2E!pCbx#1)~;>T0jR29CyAjC&_~Imv6a(EV+H< zext+YPa^I+J_^AKHRnB_gkgmphz%Co_(dGVCfWkeZEyJ?^lf$!rh0ua^eq5|D~PsS z^_UZcscr!*!f0lJ%jRctPCMUPIc$IJKobiZ8vZju6)}SFplnqD0A&uI6xHRzHvj+t M07*qoM6N<$g4|ne4gdfE literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_minimum_thermal_relief_spoke_count.png b/resources/bitmaps_png/png/constraint_minimum_thermal_relief_spoke_count.png index e0b126ee6978ca62c05987d4921f290176f32344..22de0b3b731c5d58b3b0d871b7dc74bfe7249c54 100644 GIT binary patch literal 8400 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 bW8%^@jaKp0hNJ&fc%Ue&_O4ReBKUs*(=TKV literal 12658 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 ck0tJ(P{6U7gZYz3%wjE-T(jq literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_minimum_through_hole.png b/resources/bitmaps_png/png/constraint_minimum_through_hole.png index 12f0e4571a92edbd8ed9bb62e66c22b4381b1779..c67a00f1f56cb93d9f06e3e349cef550a5de5604 100644 GIT binary patch literal 467 zcmV;^0WAKBP)k5Mgnj@JSZ7RVLY zk2i?A7#4#p0T~WrBg>sf3L^Q|Ly}l6kS>-kUetOw8|`9UAk_ZvMt-(ODT z`2S)8=YJ6WY9jmpr7ip=GJVH5#k+TM10$ISL<0?FB$!M=NsubZ6c+|%B7ByBV_it`t$a6?w;214UM=hYe1puF~{+%IJI%)s_002ov JPDHLkV1m6q#$x~g literal 9295 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 Eg40Z(u>b%7 literal 8860 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 P00000NkvXXu0mjfY<#q6 literal 8623 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 T-hdu)btJl)K#l4rwh{jYCcN1p diff --git a/resources/bitmaps_png/png/constraint_minimum_uvia_hole_dark.png b/resources/bitmaps_png/png/constraint_minimum_uvia_hole_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..74f2be6a5ca9dec74cad3bd77c73e24b6627a506 GIT binary patch literal 419 zcmV;U0bKrxP)HsJ$c7*7WLOkXz#xzS#2_}Z+{JE& z10X#x3yAW;^&W3)L2P8X^GHGDzT>qdQ5I}&WynX5mU{IjAr~n1mr7ng8SAeMngn>DD|K=8kJck4Zj?vO|)B^fh0070FH?26G1@Hg> N002ovPDHLkV1nSHvK{~c literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_minimum_via_diameter.png b/resources/bitmaps_png/png/constraint_minimum_via_diameter.png index 05c218d0db0c6acff2edd8026585438144665598..decb17303a0dd53114fc26a4069afc1d5dc0de0e 100644 GIT binary patch literal 457 zcmV;)0XF`LP)-J(fLtAw$sh>R z6j#Y0{HPD%lWRQ;FYsDm*=H%uk;(BEp9RT<3_{2jJVv$PIl)L4$Q9U+H;B3z7K1DS z84hA2%bh0_L?A3(EM3T##Ww+lbE{YnphqSsSe{^smU{D|{qaphQl+G`8F&wx8Of4V`%)$FNw=m>6BrtHG7ZviYha|}^>=+vUGbuFe z7ZC5>$qg*jctEsF-!V=YMivKZU>vP*Mu-IftjE!g*DP(F00000NkvXXu0mjfC4{)Q literal 9547 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 S7NT_tNl{KswhHhi=>Gu&WVfII diff --git a/resources/bitmaps_png/png/constraint_minimum_via_diameter_dark.png b/resources/bitmaps_png/png/constraint_minimum_via_diameter_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..038a17621acf79d6db9b5b1278b734d2554b5ae9 GIT binary patch literal 454 zcmV;%0XhDOP)-J(fLtAw$sh>R6j#Y0 z{HPD%lWRQ;FYsDm*=H%uk;(BEp9RT<3_{2jJVv$PIl)L4$Q9U+H;B3z7K1DS84hA2 z%bh0_L?A3(EM3T##Ww+lbE{YnphqSsSe{^sm zU{D|{qaphQl+G`8F&wx8Of4V`%)$FNw=m>6BrtHG7ZvV1UQ3c)*fli#XL8v8UchbV w3vP$~uXsST<*LV=FpMk?)WA4e;fxRq06M$p&HlV_qW}N^07*qoM6N<$f(I+Qp#T5? literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_permitted_layers.png b/resources/bitmaps_png/png/constraint_permitted_layers.png index fbd8b7d8b7d77426c5dcba4b1b9fc0fcc63e11a3..e39a06acfdf3fea6aa4a4138914d9f1e026900cb 100644 GIT binary patch literal 2711 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 diff --git a/resources/bitmaps_png/png/constraint_permitted_layers_dark.png b/resources/bitmaps_png/png/constraint_permitted_layers_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..ac0aec5253863045808959fbdc52b9157045beb7 GIT binary patch literal 2677 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 literal 6062 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 diff --git a/resources/bitmaps_png/png/constraint_routing_diff_pair_dark.png b/resources/bitmaps_png/png/constraint_routing_diff_pair_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..2fe62835e8143527cd6f0ae1444cc3efdfd3508b GIT binary patch literal 7499 zcmd5>XHZjJw~l}UB8Y&3)Cdtonh4TMEJy$qM5O3T6RA=Ry<;pOO0Uwz1ZmQHe?bT$ z(m_fnLV!ph#Lz-Za!>TV-~DFp%>8xm%w;Cb$;n>ptiAU-Yd_C=B8~3ovLEL^4g!JL z^1DbJ0ts>H-MDJvKSh`cN;26-{D2GHc1ZX(8I?Gbw&zHD zSEYWEoHo?=_;x0$m~G|?(y=xdqh!N$Jyt*JR)PUG%^b9_M- zaoUUD9E#7sA;9$ba#aR&=J^Gu4^dCa)bw=@QJAu2UE_MmfJlx}Vd;zeZ9z@=(7l=c z8SH|J76%CQY**z45E(cQ_{YQre1|fCK%79xAO=Ho52M! z#squ>x*UC0!C`+@pcZ|#-tE@=Tm%m;((Pg#JwF)qz^o7;W1c~|V8Be6xWI8t2|yAd zm{=eP$p1X#@hvD|38z zpsAgjkfVR@Gdj8c>oz~e?6>b9e>1LiPqh9ClUdkC8@+S-w>yV&T7ezxC zQH@bL4SU9Tl3Dn%v7;j{^Ks5h!ePUeQ`^MudEfdnqN7(-GFfss`)ZL}?_IE4_3fiv zKmPuVU``vInF-nWc2|w8$a?35br78;ey3FXvFOB>W|4yrZBLI zKy1R!Z6@%koxx~_T#J$(2uBkbsomJW8|XX&>A;p7hjZoOyNQKfq%T}FW! zW>(-ai9<+TUiWuCpPT48(rkDx=9sf}P=jxc+oUMM8yih3<1tV-H1M7F5Elr${ULC$ z-$?VRwa*>@TmGMf+L>8*cn{dlYLB@)+ekMX4)OI=EM`r{Ag82E7Bd$K_A!n(=$ zJS{0EV>_)cU&q>R&A)vTW{Z3JES&P{yTHJs^ZO}`s!Uu9FtEL93>8w6)llx*jU#|L z2Fu$9)vy*9#@&6u5m3=rZ_E3)&Yp|ouYUt0G>kG73Ti%KhX3}$H_+O9P30X@GBae; zZy|;)A1%Z!7pWU7pv?&bl3VUjS_5sKrg{zBGEi_HL-U$a_l2+Y(`+Pun+M0{r-`Na zosD&W?PwJka5&X?o79LK=U_6f7g}f2W{Z_Kb%^1F5py()Ov(&`aI#4*q-i! zfyk6jjjBotH^-o0y?`TjGSgAi1g8>*lyr=DnB$f654LUIUXo!%RNH@E_HRFYMVcHR zxN>uW1>s$PvgT*nv9%w)oApC)mkQ#VYwHAdZ<4+j7>_Q4`VdWUrR)WkV~(SV+A(tP z6jiPM>&2K~kc7kAmFyruP!a5?KK6+oi+(I)t-0m zderIk*ZbY7(;Vb&ifc^8S8^!Es&r-n8sk9D3(9^i(oDmU&|?DF+fM=mJ#vz#9bG$5 zF|5E4Tc(V@Tbcn=6SimauVR%RDd;goB3IVewE~u-(hg$$-NQDje(~8Q&rxbyOj>3T zf@wxmr~Irm#H=W5MOImfAG-(!bpom4(a1*)foTH_2*qKQ85Q*ARaw~(ipKvcC8}G~)JSge*0G@>lB8YI0HxNvaMm<} zTxL1wL|d(#3}Un!s+J|61;?c?@kHw5dxKM-*u#^oAT?%1)|_V;oS7WsKlU|w%+6B1 z4sd;0b#=wXPl_sfaG?+LRb0|vyr;so_z&zi`PY;*OwoJ~F2%iB`Z+Li5{0j^n5{nt zO;?ODehWc#+MJj7zUJpgUIyGGVlY!vQ+E`V_Anl+@GK<#jC{*HzGHx3sx|`GBp1`P z2y&R3`z~Pxlt)D}$1RQ35xpTS;Bpwp#wqGM3Nj6?) zRQO=PcyJEN#ypI$Ks`|Hf(CxnN!gfHb#dN~#kXF#vEdiq)^sX9soOr|Xab`FVpNdr z^5b(cFSVXQ_w8Add=FC>8C|U(6qj7VFMRZ&j1SwZYvpK=XI=zHYfGiLYM$KxXWSEGvpTYoy zog`Y`#4qpV{W1+@>D)iPHYrR*EKeWd$D4|1rk8D zI;HEAqxp3Pp9T1^cQmb~x!2zde#CpN$z43w&oKFEE<2l$A+yc%gI2D8#PTG90fI;M4ihi`W`fs-7W_) zGUpG0FPb_{ks8i*4hi%`&_wEn{r!A=DDFR=Gj^88k4Cg+Z3i#Z)TJa`<vq@0bQZ z1_kE@4bI-Wd|G##k60)b%0G8-NTV3d%cmHK8y*-`?N>>;|2!W9fI`ti$%O)=!jSL& z4`myArbliaSO_}`3d}p%DG8!^L5RiomV%L}Oxe`wX}EVi@lyyfp6JF=d6;#D4hjn^ zq`H%l_tFpFYbL8)O!}bBGR~|=r7lHg|Dxn*X)>=DTM7w}Jjc2T)xLIt?O&JW0T(AGK;I-ZA?=GclES_r6ZzJgA>=z+5Vp5>9gK+SW8V&_cAx(_Z=78szyF zO}&@y531xtcc~F%@p#3)AR&M&RR#=NjjQa7EGdUo8O4~6&If3E?Jp?b;nI_-{A+{R zk(=0eO)y$WeFqhZl~@l5SUNDY&s4Epcqk+!l(S*Q3}T4P4OW(5O=RqK#@!N3lr|chnhdj5?Uq}`Wb?CsANjzvKO8-6P%|Ki^^1w2W})=GUBs+D z=k_XDkPA-OiRG=vC3f>k zR}03IzHPy{O!YZ}1x3FZ?qe8CRwf44RaI?jVEBRTVSyauhLv5h*~3M%r>pKy)WfkK zdD7YnUXH|vRyh$Y__1xQOt@X8Q-g&<|_3}@t;=>5iClzsY_~S7q zV?#!VSYfrW={*m_2LFu#32SfCEPZW0hs-<9%h##`L_1RK__(CLW}N=m8)6cjW`Ftn zgfRg>3NVw9`vC6&wlmOCx|nJ;g)sSxi_!|PD=0WV+5%;~#rZP6dm z$E4#!ARaGqMrGq(_@Z4gAFZ)E3VP+iNO}YPuQK~kY*^-^IVGJN9 z<0oB1{o-oi5M*}zsCuGFX+Qg%h*~(VQZCbUyjE08z8gEkmnQ_r>5O2<21@Z`s?HCl zTfLhATTa+Q!B9SCTXx!LayuuX&2Pxaw3rP$B8tswl$+U9CS50oNvvCpaC-pnW&?$= z*eY>(N6m%&20||m$mtu#oTZ5-7j(>OQj2>NXg3WX8RnQ_494_#E&Ok>#rV0DbB8zx}0x?XJG(lsvb9{O)6T2LeWpR|d8NvF-DPmw96v9!|vA_Yxsy}rR((KtblU&Llg45e-+7!!m= zM`KbCX>COHU$noEg!yxXlsR4+2r%=H?yGde%g@^0+DBf98Y`Kr-?r|UcqQ-k#u6ze z83=<^*RIJKS~pD{IRa{6N7dSo8S?hlY=E`-$Ye_%~^2y|GV=mTtlgirJdt>@zBUM~_-Tb=qHR0oeRzV&-GHRSUWzAc?@Z)x8 z(6RvMx4)8*Ku|ZlWS*_n+dJ|W0`laBA+x8pds@@pS8J*GMQ}QIK4Hy|lCf?Mrp?QK zthc8u?>3fM*J($-N=-1|HDfHJK_P^*u8>!3l}d+6-Hf~lAy+|ys(~!y?xRB(Q&(&RH8hyu+=CYiJ}8ob558AI|?8(V^1hrj4Y@%S@hE%)s59!7s!gh zS^4AiWJlp+%?PI9DctwYMA=LpA=#My^CI}L%K(7Qihieu&rs!GbMXo4c%m{qcUsiB zW0zH%ecU|28hqaFH2M<~iLE;{e$k~fB~_CV(bj0Wbsxh61>4`rZN|2J+|5FU_X`SL ze!E4cg|#6CvF%1Rb@lw0d99zxZVr|TPv%~d zxP7-G+HFLg3jp?(e#3`mH8EJ~wUw)&8-c#d_d<{N&Xm@{)Z{@2->b3Jj>5>$+^b+A z&+vAc&ssC3JeJNF1{TyU6+4S`nPxcTXevDIf{InG8+_aR3Hxez@4CkHl9fB#(h{TztHszi1P z#?R{U3a2uvqUJpxe#ta64WTGjXcSp`DP?qI-t=*agx!e}KG=%v>P*<}s1255#+Y`v z_osLh02Wv1i8-6Yy`Mt1t+|i?c%3h7R#Z1OAF}Fc7YTI#MmrHaZnr3bd`mxb(n&Qq zaKh~I0q1%+(OUK`CVmp&{7^k({sd~3+&h|v>>(bq31ntd9_uE(MZ++I2+ zgjXlksW2Gt9bUNa;de>bG}CKFlk}m@l1uJRrWaubjS3*hr4*+I#GZzU3DL2I4q4@Lt>sS@9Eb4 z%;5OxbS6vB(l-)R7}DhuTuuWfE|uOju+YlrYh8RO zVnTnbtx8L_Pf%}x#c7IIXZpcI^*u5z(}#>@MDVx^a4YDsppY&PD+uFnlJQ^n37uoO zfd`FyW}D^k4Eco4Q#Rs2M>!3`WIRP%s0;4)kWio19<{}VkiLE0nfp3&%>5&bOBWj6 ziVcilRAb`u0XAaX!5`RucCV?!FsgYjPlyMfI>GO=tBJ6(rviNfl^^e>UVCnPIgWvL zIbjeB>P##uzU8}VUZbZ;VPK=%C|0Bhg^(7XOf2|&=m1?Yd#^h+?fB@qeTfAxC`Hhc&ZOiBjyqRzvA zlo?@IvXfqnL)@9kk8}|z#-f7fcF$d~K zh_C#;;%l*c$GFDy!hOedRr*rI?RT)h(pPLSk2yoOlqftaD}Hb%SFlAmWrJg&@A(P( iQ~s~Sz&IhAi1%YG^c!j72B0*8^mOjrD7|L${67FS9N4@7 literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_routing_width.png b/resources/bitmaps_png/png/constraint_routing_width.png index 0947c01f1cd683197e0dd871e71cd3c3239b5c75..f4e1ecf6efe64172918db7b8f5bedd0c68288edf 100644 GIT binary patch literal 2537 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 literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_silk_clearance.png b/resources/bitmaps_png/png/constraint_silk_clearance.png new file mode 100644 index 0000000000000000000000000000000000000000..f43b0f4ef9d04f549b2e307cd719422453ed8944 GIT binary patch literal 515 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 Rb4&}+(KOVkdGI*)e*h{GB&z@b literal 6101 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 LOGvHJ&6xiJ+E`*H diff --git a/resources/bitmaps_png/png/constraint_silk_to_soldermask_clearance_dark.png b/resources/bitmaps_png/png/constraint_silk_to_soldermask_clearance_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..7cef852c9c9a4a550963c41cf8d2e1611a84b5b5 GIT binary patch literal 7534 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 literal 3920 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 VmzuqSz|OC5+{yiD#o_b#e*z@{E0_QP literal 2648 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 literal 0 HcmV?d00001 diff --git a/resources/bitmaps_png/png/constraint_vias_under_smd.png b/resources/bitmaps_png/png/constraint_vias_under_smd.png new file mode 100644 index 0000000000000000000000000000000000000000..3940b618e986accd3c84873b07c3b39658345a0a GIT binary patch literal 4311 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 - + sodipodi:nodetypes="ccc" /> diff --git a/resources/bitmaps_png/sources/dark/constraints/absolute-length-2.svg b/resources/bitmaps_png/sources/dark/constraints/absolute-length-2.svg new file mode 100644 index 0000000000..0d35f0dbd6 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/absolute-length-2.svg @@ -0,0 +1,138 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/allowed-orientation.svg b/resources/bitmaps_png/sources/dark/constraints/allowed-orientation.svg new file mode 100644 index 0000000000..07d2d57f99 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/allowed-orientation.svg @@ -0,0 +1,239 @@ + + + + + + U2 diff --git a/resources/bitmaps_png/sources/dark/constraints/basic-clearance.svg b/resources/bitmaps_png/sources/dark/constraints/basic-clearance.svg new file mode 100644 index 0000000000..f169576871 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/basic-clearance.svg @@ -0,0 +1,156 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/board-outline-clearance.svg b/resources/bitmaps_png/sources/dark/constraints/board-outline-clearance.svg new file mode 100644 index 0000000000..a277e48020 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/board-outline-clearance.svg @@ -0,0 +1,144 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/clearance.svg b/resources/bitmaps_png/sources/dark/constraints/clearance.svg new file mode 100644 index 0000000000..e9c20b79ad --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/clearance.svg @@ -0,0 +1,159 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/copper-to-hole-clearance.svg b/resources/bitmaps_png/sources/dark/constraints/copper-to-hole-clearance.svg new file mode 100644 index 0000000000..16abc31eef --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/copper-to-hole-clearance.svg @@ -0,0 +1,182 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/copper_to_edge_clearance.svg b/resources/bitmaps_png/sources/dark/constraints/copper_to_edge_clearance.svg new file mode 100644 index 0000000000..1d01533cd9 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/copper_to_edge_clearance.svg @@ -0,0 +1,293 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/creepage-distance.svg b/resources/bitmaps_png/sources/dark/constraints/creepage-distance.svg new file mode 100644 index 0000000000..bc3d8383b5 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/creepage-distance.svg @@ -0,0 +1,295 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/hole-size.svg b/resources/bitmaps_png/sources/dark/constraints/hole-size.svg new file mode 100644 index 0000000000..4c056f0a5c --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/hole-size.svg @@ -0,0 +1,178 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/hole-to-hole-clearance.svg b/resources/bitmaps_png/sources/dark/constraints/hole-to-hole-clearance.svg new file mode 100644 index 0000000000..570c4c4776 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/hole-to-hole-clearance.svg @@ -0,0 +1,210 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/hole-to-hole-distance.svg b/resources/bitmaps_png/sources/dark/constraints/hole-to-hole-distance.svg new file mode 100644 index 0000000000..89ec1f9830 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/hole-to-hole-distance.svg @@ -0,0 +1,119 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/length.svg b/resources/bitmaps_png/sources/dark/constraints/length.svg new file mode 100644 index 0000000000..3773c399f6 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/length.svg @@ -0,0 +1,203 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/matched-length-diff-pair.svg b/resources/bitmaps_png/sources/dark/constraints/matched-length-diff-pair.svg new file mode 100644 index 0000000000..b7687e962b --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/matched-length-diff-pair.svg @@ -0,0 +1,137 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/maximum-allowed-deviation.svg b/resources/bitmaps_png/sources/dark/constraints/maximum-allowed-deviation.svg new file mode 100644 index 0000000000..9b81bec619 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/maximum-allowed-deviation.svg @@ -0,0 +1,175 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/maximum-via-count.svg b/resources/bitmaps_png/sources/dark/constraints/maximum-via-count.svg new file mode 100644 index 0000000000..8a2f8b561d --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/maximum-via-count.svg @@ -0,0 +1,235 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/minimum-angular-ring.svg b/resources/bitmaps_png/sources/dark/constraints/minimum-angular-ring.svg new file mode 100644 index 0000000000..afa6c7252f --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/minimum-angular-ring.svg @@ -0,0 +1,105 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/minimum-annular-width.svg b/resources/bitmaps_png/sources/dark/constraints/minimum-annular-width.svg new file mode 100644 index 0000000000..c569f2c7c4 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/minimum-annular-width.svg @@ -0,0 +1,182 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/minimum-clearance.svg b/resources/bitmaps_png/sources/dark/constraints/minimum-clearance.svg new file mode 100644 index 0000000000..43727776cc --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/minimum-clearance.svg @@ -0,0 +1,195 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/minimum-connection-width.svg b/resources/bitmaps_png/sources/dark/constraints/minimum-connection-width.svg new file mode 100644 index 0000000000..b54c30c93a --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/minimum-connection-width.svg @@ -0,0 +1,274 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/minimum-item-clearance.svg b/resources/bitmaps_png/sources/dark/constraints/minimum-item-clearance.svg new file mode 100644 index 0000000000..90db23b657 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/minimum-item-clearance.svg @@ -0,0 +1,193 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + R1 + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/minimum-soldermask-silver.svg b/resources/bitmaps_png/sources/dark/constraints/minimum-soldermask-silver.svg new file mode 100644 index 0000000000..81fa8f5b6f --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/minimum-soldermask-silver.svg @@ -0,0 +1,202 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/minimum-text-height-and-thickness.svg b/resources/bitmaps_png/sources/dark/constraints/minimum-text-height-and-thickness.svg new file mode 100644 index 0000000000..1e49b70140 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/minimum-text-height-and-thickness.svg @@ -0,0 +1,194 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/minimum-through-hole.svg b/resources/bitmaps_png/sources/dark/constraints/minimum-through-hole.svg new file mode 100644 index 0000000000..044c088f21 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/minimum-through-hole.svg @@ -0,0 +1,182 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/minimum-track-width.svg b/resources/bitmaps_png/sources/dark/constraints/minimum-track-width.svg new file mode 100644 index 0000000000..3b40099093 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/minimum-track-width.svg @@ -0,0 +1,190 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/minimum-uvia-diameter.svg b/resources/bitmaps_png/sources/dark/constraints/minimum-uvia-diameter.svg new file mode 100644 index 0000000000..9d5998a7f6 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/minimum-uvia-diameter.svg @@ -0,0 +1,177 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/minimum-uvia-hole.svg b/resources/bitmaps_png/sources/dark/constraints/minimum-uvia-hole.svg new file mode 100644 index 0000000000..10a99a6887 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/minimum-uvia-hole.svg @@ -0,0 +1,177 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/minimum-via-diameter.svg b/resources/bitmaps_png/sources/dark/constraints/minimum-via-diameter.svg new file mode 100644 index 0000000000..41399e8606 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/minimum-via-diameter.svg @@ -0,0 +1,185 @@ + + + + + + + + + + image/svg+xml + + ps_diff_pair_tune_phase + + + + + + + + + + + + + + + + + + + + + + + + + + + ps_diff_pair_tune_phase + + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/minimum_thermal_relief_spoke_count.svg b/resources/bitmaps_png/sources/dark/constraints/minimum_thermal_relief_spoke_count.svg new file mode 100644 index 0000000000..8fbf7b0391 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/minimum_thermal_relief_spoke_count.svg @@ -0,0 +1,457 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/permitted-layers.svg b/resources/bitmaps_png/sources/dark/constraints/permitted-layers.svg new file mode 100644 index 0000000000..2e62f92b04 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/permitted-layers.svg @@ -0,0 +1,409 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/routing-diff-pair.svg b/resources/bitmaps_png/sources/dark/constraints/routing-diff-pair.svg new file mode 100644 index 0000000000..2e0018c9c0 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/routing-diff-pair.svg @@ -0,0 +1,377 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/routing-width.svg b/resources/bitmaps_png/sources/dark/constraints/routing-width.svg new file mode 100644 index 0000000000..116b46f8b3 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/routing-width.svg @@ -0,0 +1,248 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/silk-to-soldermask-clearance.svg b/resources/bitmaps_png/sources/dark/constraints/silk-to-soldermask-clearance.svg new file mode 100644 index 0000000000..99c58932f2 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/silk-to-soldermask-clearance.svg @@ -0,0 +1,190 @@ + + + + + + 123456 diff --git a/resources/bitmaps_png/sources/dark/constraints/silk_clearance.svg b/resources/bitmaps_png/sources/dark/constraints/silk_clearance.svg new file mode 100644 index 0000000000..003b4610e4 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/silk_clearance.svg @@ -0,0 +1,292 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + R1 + + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/soldermask-expansion.svg b/resources/bitmaps_png/sources/dark/constraints/soldermask-expansion.svg new file mode 100644 index 0000000000..f9aee9fa78 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/soldermask-expansion.svg @@ -0,0 +1,160 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/solderpaste-expansion.svg b/resources/bitmaps_png/sources/dark/constraints/solderpaste-expansion.svg new file mode 100644 index 0000000000..0858477535 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/solderpaste-expansion.svg @@ -0,0 +1,145 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/via-style.svg b/resources/bitmaps_png/sources/dark/constraints/via-style.svg new file mode 100644 index 0000000000..fe66b54c92 --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/via-style.svg @@ -0,0 +1,123 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/dark/constraints/vias-under-smd.svg b/resources/bitmaps_png/sources/dark/constraints/vias-under-smd.svg new file mode 100644 index 0000000000..d5366f591e --- /dev/null +++ b/resources/bitmaps_png/sources/dark/constraints/vias-under-smd.svg @@ -0,0 +1,102 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/absolute-length-2.svg b/resources/bitmaps_png/sources/light/constraints/absolute-length-2.svg new file mode 100644 index 0000000000..f4ca7b74d9 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/absolute-length-2.svg @@ -0,0 +1,138 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/allowed-orientation.svg b/resources/bitmaps_png/sources/light/constraints/allowed-orientation.svg new file mode 100644 index 0000000000..92cbc1146e --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/allowed-orientation.svg @@ -0,0 +1,239 @@ + + + + + + U2 diff --git a/resources/bitmaps_png/sources/light/constraints/basic-clearance.svg b/resources/bitmaps_png/sources/light/constraints/basic-clearance.svg new file mode 100644 index 0000000000..ae449cfda3 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/basic-clearance.svg @@ -0,0 +1,156 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/board-outline-clearance.svg b/resources/bitmaps_png/sources/light/constraints/board-outline-clearance.svg new file mode 100644 index 0000000000..799b5c95c1 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/board-outline-clearance.svg @@ -0,0 +1,144 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/clearance.svg b/resources/bitmaps_png/sources/light/constraints/clearance.svg new file mode 100644 index 0000000000..99ca9e9473 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/clearance.svg @@ -0,0 +1,157 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/copper-to-hole-clearance.svg b/resources/bitmaps_png/sources/light/constraints/copper-to-hole-clearance.svg new file mode 100644 index 0000000000..879a740fee --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/copper-to-hole-clearance.svg @@ -0,0 +1,182 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/copper_to_edge_clearance.svg b/resources/bitmaps_png/sources/light/constraints/copper_to_edge_clearance.svg new file mode 100644 index 0000000000..fd72d66c4f --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/copper_to_edge_clearance.svg @@ -0,0 +1,293 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/creepage-distance.svg b/resources/bitmaps_png/sources/light/constraints/creepage-distance.svg new file mode 100644 index 0000000000..f284200251 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/creepage-distance.svg @@ -0,0 +1,295 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/hole-size.svg b/resources/bitmaps_png/sources/light/constraints/hole-size.svg new file mode 100644 index 0000000000..25a2fc0525 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/hole-size.svg @@ -0,0 +1,178 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/hole-to-hole-clearance.svg b/resources/bitmaps_png/sources/light/constraints/hole-to-hole-clearance.svg new file mode 100644 index 0000000000..b579912ffc --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/hole-to-hole-clearance.svg @@ -0,0 +1,210 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/hole-to-hole-distance.svg b/resources/bitmaps_png/sources/light/constraints/hole-to-hole-distance.svg new file mode 100644 index 0000000000..3a019a063d --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/hole-to-hole-distance.svg @@ -0,0 +1,119 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/length.svg b/resources/bitmaps_png/sources/light/constraints/length.svg new file mode 100644 index 0000000000..ac29158d95 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/length.svg @@ -0,0 +1,203 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/matched-length-diff-pair.svg b/resources/bitmaps_png/sources/light/constraints/matched-length-diff-pair.svg new file mode 100644 index 0000000000..9825cf70dc --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/matched-length-diff-pair.svg @@ -0,0 +1,137 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/maximum-allowed-deviation.svg b/resources/bitmaps_png/sources/light/constraints/maximum-allowed-deviation.svg new file mode 100644 index 0000000000..76af295345 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/maximum-allowed-deviation.svg @@ -0,0 +1,175 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/maximum-via-count.svg b/resources/bitmaps_png/sources/light/constraints/maximum-via-count.svg new file mode 100644 index 0000000000..ac98e2153c --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/maximum-via-count.svg @@ -0,0 +1,231 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/minimum-angular-ring.svg b/resources/bitmaps_png/sources/light/constraints/minimum-angular-ring.svg new file mode 100644 index 0000000000..ec43ad4962 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/minimum-angular-ring.svg @@ -0,0 +1,105 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/minimum-annular-width.svg b/resources/bitmaps_png/sources/light/constraints/minimum-annular-width.svg new file mode 100644 index 0000000000..75db218dd2 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/minimum-annular-width.svg @@ -0,0 +1,182 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/minimum-clearance.svg b/resources/bitmaps_png/sources/light/constraints/minimum-clearance.svg new file mode 100644 index 0000000000..3a3fa9505d --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/minimum-clearance.svg @@ -0,0 +1,195 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/minimum-connection-width.svg b/resources/bitmaps_png/sources/light/constraints/minimum-connection-width.svg new file mode 100644 index 0000000000..73ac015a36 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/minimum-connection-width.svg @@ -0,0 +1,274 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/minimum-item-clearance.svg b/resources/bitmaps_png/sources/light/constraints/minimum-item-clearance.svg new file mode 100644 index 0000000000..4ee88500ba --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/minimum-item-clearance.svg @@ -0,0 +1,193 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + R1 + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/minimum-soldermask-silver.svg b/resources/bitmaps_png/sources/light/constraints/minimum-soldermask-silver.svg new file mode 100644 index 0000000000..496e4c36c7 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/minimum-soldermask-silver.svg @@ -0,0 +1,202 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/minimum-text-height-and-thickness.svg b/resources/bitmaps_png/sources/light/constraints/minimum-text-height-and-thickness.svg new file mode 100644 index 0000000000..2173138a69 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/minimum-text-height-and-thickness.svg @@ -0,0 +1,194 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/minimum-through-hole.svg b/resources/bitmaps_png/sources/light/constraints/minimum-through-hole.svg new file mode 100644 index 0000000000..aebee74aa5 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/minimum-through-hole.svg @@ -0,0 +1,182 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/minimum-track-width.svg b/resources/bitmaps_png/sources/light/constraints/minimum-track-width.svg new file mode 100644 index 0000000000..b8a8c36684 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/minimum-track-width.svg @@ -0,0 +1,190 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/minimum-uvia-diameter.svg b/resources/bitmaps_png/sources/light/constraints/minimum-uvia-diameter.svg new file mode 100644 index 0000000000..0b61838483 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/minimum-uvia-diameter.svg @@ -0,0 +1,177 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/minimum-uvia-hole.svg b/resources/bitmaps_png/sources/light/constraints/minimum-uvia-hole.svg new file mode 100644 index 0000000000..6b245dfd84 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/minimum-uvia-hole.svg @@ -0,0 +1,177 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/minimum-via-diameter.svg b/resources/bitmaps_png/sources/light/constraints/minimum-via-diameter.svg new file mode 100644 index 0000000000..96197f8c77 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/minimum-via-diameter.svg @@ -0,0 +1,185 @@ + + + + + + + + + + image/svg+xml + + ps_diff_pair_tune_phase + + + + + + + + + + + + + + + + + + + + + + + + + + + ps_diff_pair_tune_phase + + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/minimum_thermal_relief_spoke_count.svg b/resources/bitmaps_png/sources/light/constraints/minimum_thermal_relief_spoke_count.svg new file mode 100644 index 0000000000..225ba45bb6 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/minimum_thermal_relief_spoke_count.svg @@ -0,0 +1,457 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/permitted-layers.svg b/resources/bitmaps_png/sources/light/constraints/permitted-layers.svg new file mode 100644 index 0000000000..a26af52a4a --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/permitted-layers.svg @@ -0,0 +1,409 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/routing-diff-pair.svg b/resources/bitmaps_png/sources/light/constraints/routing-diff-pair.svg new file mode 100644 index 0000000000..7feced25ff --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/routing-diff-pair.svg @@ -0,0 +1,379 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/routing-width.svg b/resources/bitmaps_png/sources/light/constraints/routing-width.svg new file mode 100644 index 0000000000..75d009f7af --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/routing-width.svg @@ -0,0 +1,248 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/silk-to-soldermask-clearance.svg b/resources/bitmaps_png/sources/light/constraints/silk-to-soldermask-clearance.svg new file mode 100644 index 0000000000..702e074214 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/silk-to-soldermask-clearance.svg @@ -0,0 +1,190 @@ + + + + + + 123456 diff --git a/resources/bitmaps_png/sources/light/constraints/silk_clearance.svg b/resources/bitmaps_png/sources/light/constraints/silk_clearance.svg new file mode 100644 index 0000000000..ee95357409 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/silk_clearance.svg @@ -0,0 +1,292 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + R1 + + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/soldermask-expansion.svg b/resources/bitmaps_png/sources/light/constraints/soldermask-expansion.svg new file mode 100644 index 0000000000..9dc4324665 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/soldermask-expansion.svg @@ -0,0 +1,160 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/solderpaste-expansion.svg b/resources/bitmaps_png/sources/light/constraints/solderpaste-expansion.svg new file mode 100644 index 0000000000..e5b99fe559 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/solderpaste-expansion.svg @@ -0,0 +1,145 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/via-style.svg b/resources/bitmaps_png/sources/light/constraints/via-style.svg new file mode 100644 index 0000000000..a391d0a258 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/via-style.svg @@ -0,0 +1,123 @@ + + + + + + diff --git a/resources/bitmaps_png/sources/light/constraints/vias-under-smd.svg b/resources/bitmaps_png/sources/light/constraints/vias-under-smd.svg new file mode 100644 index 0000000000..8135f43ef9 --- /dev/null +++ b/resources/bitmaps_png/sources/light/constraints/vias-under-smd.svg @@ -0,0 +1,102 @@ + + + + + +