1 /* 2 VeroRoute - Qt based Veroboard/Perfboard/PCB layout & routing application. 3 4 Copyright (C) 2017 Alex Lawrow ( dralx@users.sourceforge.net ) 5 6 This program is free software: you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation, either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. 18 */ 19 20 #pragma once 21 22 #include "Common.h" 23 #include "qnamespace.h" 24 25 // Enumeration and static methods for the component types 26 27 //*** Don't delete or modify existing values in COMP. Just add new ones and update all methods below. *** 28 enum class COMP { INVALID = -1, 29 MARK = 0, 30 PAD = 100, 31 PAD_FLYINGWIRE = 110, 32 WIRE = 200, 33 RESISTOR = 300, 34 INDUCTOR = 350, 35 DIODE = 400, 36 LED = 450, 37 CAP_CERAMIC = 500, 38 CAP_FILM = 600, 39 CAP_FILM_WIDE = 620, 40 CAP_ELECTRO_200_NP = 700, 41 CAP_ELECTRO_250_NP = 710, 42 CAP_ELECTRO_300_NP = 720, 43 CAP_ELECTRO_400_NP = 730, 44 CAP_ELECTRO_500_NP = 740, 45 CAP_ELECTRO_600_NP = 750, 46 CAP_ELECTRO_200 = 800, 47 CAP_ELECTRO_250 = 900, 48 CAP_ELECTRO_300 = 1000, 49 CAP_ELECTRO_400 = 1010, 50 CAP_ELECTRO_500 = 1020, 51 CAP_ELECTRO_600 = 1030, 52 TO92 = 1100, 53 TO18 = 1120, 54 TO39 = 1130, 55 TO220 = 1140, 56 TRIM_VERT = 1200, 57 TRIM_VERT_OFFSET = 1300, 58 TRIM_VERT_OFFSET_WIDE = 1350, 59 TRIM_FLAT = 1400, 60 TRIM_FLAT_WIDE = 1450, 61 TRIM_3006P = 1451, 62 TRIM_3006W = 1452, 63 TRIM_3006Y = 1453, 64 TRIM_3329H = 1460, 65 TRIM_3329P_DK9_RC = 1465, 66 TRIM_3362F = 1470, 67 TRIM_3362H = 1471, 68 TRIM_3362P = 1472, 69 TRIM_3362R = 1473, 70 TRIM_3362U = 1474, 71 TRIM_3362M = 1475, 72 TRIM_3362S = 1476, 73 TRIM_3362W = 1477, 74 TRIM_3362X = 1478, 75 TRIM_3362Z = 1479, 76 SIP = 1500, 77 DIP = 1600, 78 DIP_RECTIFIER = 1620, 79 STRIP_100 = 1900, 80 BLOCK_100 = 1910, 81 BLOCK_200 = 1920, 82 SWITCH_ST = 2000, 83 SWITCH_DT = 2100, 84 SWITCH_ST_DIP = 2200, 85 SWITCH_BUTTON_4PIN = 2250, 86 CRYSTAL = 3000, 87 RELAY_HK19F = 4000, 88 RELAY_HJR_4102 = 4010, 89 RELAY_FTR_B3C = 4020, 90 RELAY_G2R_2 = 4030, 91 RELAY_G2R_2A = 4032, 92 RELAY_G2RK_2 = 4034, 93 RELAY_G2RK_2A = 4036, 94 RELAY_G3MB_202P = 4037, 95 RELAY_JQC_3F_APPROX = 4038, 96 RELAY_S1A050000 = 4040, 97 RELAY_TRCD = 4042, 98 RELAY_DIP_4PIN = 4050, 99 RELAY_DIP_8PIN = 4052, 100 FUSE_HOLDER = 5000, 101 VERO_NUMBER = 10000, // Not a real component. Used for labeling vero-boards 102 VERO_LETTER = 10001, // Not a real component. Used for labeling vero-boards 103 CUSTOM = 100000, // A user-defined component 104 TRACKS = 1000000 // A track pattern 105 }; 106 //*** Don't delete or modify existing values in COMP. Just add new ones and update all methods below. *** 107 108 struct CompTypes 109 { UpdateMapsCompTypes110 static void UpdateMaps(const COMP& eType, const std::string& typeStr, const std::string& importStr) 111 { 112 sm_mapCompTypeToTypeStr[eType] = typeStr; 113 sm_mapCompTypeToImportStr[eType] = importStr; 114 sm_listCompTypes.push_back(eType); 115 } InitMapsCompTypeToStrCompTypes116 static void InitMapsCompTypeToStr() 117 { 118 if ( !sm_mapCompTypeToTypeStr.empty() ) return; 119 UpdateMaps(COMP::MARK, "Marker", ""); // No import string 120 UpdateMaps(COMP::PAD, "Pad", "PAD"); 121 UpdateMaps(COMP::PAD_FLYINGWIRE, "Pad (Flying Wire)", "PAD_FLYINGWIRE"); 122 UpdateMaps(COMP::WIRE, "Wire", ""); // No import string 123 UpdateMaps(COMP::RESISTOR, "Resistor", "RESISTOR"); 124 UpdateMaps(COMP::INDUCTOR, "Inductor", "INDUCTOR"); 125 UpdateMaps(COMP::DIODE, "Diode", "DIODE"); 126 UpdateMaps(COMP::LED, "LED", "LED"); 127 UpdateMaps(COMP::CAP_CERAMIC, "Ceramic", "CAP_CERAMIC"); 128 UpdateMaps(COMP::CAP_FILM, "Film", "CAP_FILM"); 129 UpdateMaps(COMP::CAP_FILM_WIDE, "Film (Wide)", "CAP_FILM_WIDE"); 130 UpdateMaps(COMP::CAP_ELECTRO_200, "Electrolytic 200 mil", "CAP_ELECTRO_200"); 131 UpdateMaps(COMP::CAP_ELECTRO_250, "Electrolytic 250 mil", "CAP_ELECTRO_250"); 132 UpdateMaps(COMP::CAP_ELECTRO_300, "Electrolytic 300 mil", "CAP_ELECTRO_300"); 133 UpdateMaps(COMP::CAP_ELECTRO_400, "Electrolytic 400 mil", "CAP_ELECTRO_400"); 134 UpdateMaps(COMP::CAP_ELECTRO_500, "Electrolytic 500 mil", "CAP_ELECTRO_500"); 135 UpdateMaps(COMP::CAP_ELECTRO_600, "Electrolytic 600 mil", "CAP_ELECTRO_600"); 136 UpdateMaps(COMP::CAP_ELECTRO_200_NP, "Electrolytic NP 200 mil", "CAP_ELECTRO_200_NP"); 137 UpdateMaps(COMP::CAP_ELECTRO_250_NP, "Electrolytic NP 250 mil", "CAP_ELECTRO_250_NP"); 138 UpdateMaps(COMP::CAP_ELECTRO_300_NP, "Electrolytic NP 300 mil", "CAP_ELECTRO_300_NP"); 139 UpdateMaps(COMP::CAP_ELECTRO_400_NP, "Electrolytic NP 400 mil", "CAP_ELECTRO_400_NP"); 140 UpdateMaps(COMP::CAP_ELECTRO_500_NP, "Electrolytic NP 500 mil", "CAP_ELECTRO_500_NP"); 141 UpdateMaps(COMP::CAP_ELECTRO_600_NP, "Electrolytic NP 600 mil", "CAP_ELECTRO_600_NP"); 142 UpdateMaps(COMP::TO92, "TO92", "TO92"); 143 UpdateMaps(COMP::TO18, "TO18", "TO18"); 144 UpdateMaps(COMP::TO39, "TO39", "TO39"); 145 UpdateMaps(COMP::TO220, "TO220", "TO220"); 146 UpdateMaps(COMP::TRIM_VERT, "Vertical", "TRIM_VERT"); 147 UpdateMaps(COMP::TRIM_VERT_OFFSET, "Vertical Offset", "TRIM_VERT_OFFSET"); 148 UpdateMaps(COMP::TRIM_VERT_OFFSET_WIDE, "Vertical Offset (Wide Gap)", "TRIM_VERT_OFFSET_WIDE"); 149 UpdateMaps(COMP::TRIM_FLAT, "Flat", "TRIM_FLAT"); 150 UpdateMaps(COMP::TRIM_FLAT_WIDE, "Flat (Wide Gap)", "TRIM_FLAT_WIDE"); 151 UpdateMaps(COMP::TRIM_3006P, "Bourns 3006P", "TRIM_3006P"); 152 UpdateMaps(COMP::TRIM_3006W, "Bourns 3006W", "TRIM_3006W"); 153 UpdateMaps(COMP::TRIM_3006Y, "Bourns 3006Y", "TRIM_3006Y"); 154 UpdateMaps(COMP::TRIM_3329H, "Bourns 3329H", "TRIM_3329H"); 155 UpdateMaps(COMP::TRIM_3329P_DK9_RC, "Bourns 3329P-DK9-RC", "TRIM_3329P_DK9_RC"); 156 UpdateMaps(COMP::TRIM_3362F, "Bourns 3362F", "TRIM_3362F"); 157 UpdateMaps(COMP::TRIM_3362H, "Bourns 3362H", "TRIM_3362H"); 158 UpdateMaps(COMP::TRIM_3362P, "Bourns 3362P", "TRIM_3362P"); 159 UpdateMaps(COMP::TRIM_3362R, "Bourns 3362R", "TRIM_3362R"); 160 UpdateMaps(COMP::TRIM_3362U, "Bourns 3362U", "TRIM_3362U"); 161 UpdateMaps(COMP::TRIM_3362M, "Bourns 3362M", "TRIM_3362M"); 162 UpdateMaps(COMP::TRIM_3362S, "Bourns 3362S", "TRIM_3362S"); 163 UpdateMaps(COMP::TRIM_3362W, "Bourns 3362W", "TRIM_3362W"); 164 UpdateMaps(COMP::TRIM_3362X, "Bourns 3362X", "TRIM_3362X"); 165 UpdateMaps(COMP::TRIM_3362Z, "Bourns 3362Z", "TRIM_3362Z"); 166 UpdateMaps(COMP::SIP, "SIP", "SIP"); 167 UpdateMaps(COMP::DIP, "DIP", "DIP"); 168 UpdateMaps(COMP::DIP_RECTIFIER, "DIP (Rectifier)", "DIP_RECTIFIER"); 169 UpdateMaps(COMP::STRIP_100, "Pin Strip (100 mil)", "STRIP_100MIL"); 170 UpdateMaps(COMP::BLOCK_100, "Terminal Block (100 mil)", "BLOCK_100MIL"); 171 UpdateMaps(COMP::BLOCK_200, "Terminal Block (200 mil)", "BLOCK_200MIL"); 172 UpdateMaps(COMP::SWITCH_ST, "Single Throw", "SWITCH_ST"); 173 UpdateMaps(COMP::SWITCH_DT, "Double Throw", "SWITCH_DT"); 174 UpdateMaps(COMP::SWITCH_ST_DIP, "Single Throw (DIP)", "SWITCH_ST_DIP"); 175 UpdateMaps(COMP::SWITCH_BUTTON_4PIN, "Button (4 pin)", "SWITCH_BUTTON_4PIN"); 176 UpdateMaps(COMP::CRYSTAL, "Crystal", "CRYSTAL"); 177 UpdateMaps(COMP::RELAY_HK19F, "HK19F", "RELAY_HK19F"); 178 UpdateMaps(COMP::RELAY_HJR_4102, "HJR-4102", "RELAY_HJR_4102"); 179 UpdateMaps(COMP::RELAY_FTR_B3C, "FTR-B3C", "RELAY_FTR_B3C"); 180 UpdateMaps(COMP::RELAY_G2R_2, "G2R-2", "RELAY_G2R_2"); 181 UpdateMaps(COMP::RELAY_G2R_2A, "G2R-2A", "RELAY_G2R_2A"); 182 UpdateMaps(COMP::RELAY_G2RK_2, "G2RK-2", "RELAY_G2RK_2"); 183 UpdateMaps(COMP::RELAY_G2RK_2A, "G2RK-2A", "RELAY_G2RK_2A"); 184 UpdateMaps(COMP::RELAY_G3MB_202P, "G3MB_202P", "RELAY_G3MB_202P"); 185 UpdateMaps(COMP::RELAY_JQC_3F_APPROX, "JQC-3F (approx)", "RELAY_JQC_3F_APPROX"); 186 UpdateMaps(COMP::RELAY_S1A050000, "S1A050000", "RELAY_S1A050000"); 187 UpdateMaps(COMP::RELAY_TRCD, "TRCD", "RELAY_TRCD"); 188 UpdateMaps(COMP::RELAY_DIP_4PIN, "DIP 4-pin", "RELAY_DIP_4PIN"); 189 UpdateMaps(COMP::RELAY_DIP_8PIN, "DIP 8-pin", "RELAY_DIP_8PIN"); 190 UpdateMaps(COMP::FUSE_HOLDER, "Fuse Holder", "FUSE_HOLDER"); 191 UpdateMaps(COMP::VERO_NUMBER, "Vero Numbers", ""); // No import string 192 UpdateMaps(COMP::VERO_LETTER, "Vero Letters", ""); // No import string 193 UpdateMaps(COMP::CUSTOM, "Custom", ""); // No import string (user-defined shapes have their own strings) 194 UpdateMaps(COMP::TRACKS, "Tracks", ""); // No import string 195 } GetListCompTypesCompTypes196 static const std::list<COMP>& GetListCompTypes() 197 { 198 InitMapsCompTypeToStr(); 199 return sm_listCompTypes; 200 } GetTypeFromTypeStrCompTypes201 static COMP GetTypeFromTypeStr(const std::string& str) 202 { 203 InitMapsCompTypeToStr(); 204 for (const auto& mapObj : sm_mapCompTypeToTypeStr) 205 if ( mapObj.second == str ) return mapObj.first; 206 return COMP::INVALID; 207 } GetDefaultImportStrCompTypes208 static std::string GetDefaultImportStr(const COMP& eType) 209 { 210 InitMapsCompTypeToStr(); 211 const auto iter = sm_mapCompTypeToImportStr.find(eType); 212 if ( iter != sm_mapCompTypeToImportStr.end() ) return iter->second; 213 return "INVALID"; 214 } GetDefaultTypeStrCompTypes215 static std::string GetDefaultTypeStr(const COMP& eType) 216 { 217 InitMapsCompTypeToStr(); 218 const auto iter = sm_mapCompTypeToTypeStr.find(eType); 219 if ( iter != sm_mapCompTypeToTypeStr.end() ) return iter->second; 220 return "INVALID"; 221 } GetListOrderCompTypes222 static int GetListOrder(const COMP& eType) // For dialogs/menus. Lower number ==> higher up list 223 { 224 switch( eType ) 225 { 226 case COMP::PAD: return 0; 227 case COMP::PAD_FLYINGWIRE: return 1; 228 case COMP::WIRE: return 2; 229 case COMP::RESISTOR: return 3; 230 case COMP::INDUCTOR: return 4; 231 case COMP::CAP_CERAMIC: 232 case COMP::CAP_FILM: 233 case COMP::CAP_FILM_WIDE: return 5; 234 case COMP::CAP_ELECTRO_200: 235 case COMP::CAP_ELECTRO_250: 236 case COMP::CAP_ELECTRO_300: 237 case COMP::CAP_ELECTRO_400: 238 case COMP::CAP_ELECTRO_500: 239 case COMP::CAP_ELECTRO_600: return 6; 240 case COMP::CAP_ELECTRO_200_NP: 241 case COMP::CAP_ELECTRO_250_NP: 242 case COMP::CAP_ELECTRO_300_NP: 243 case COMP::CAP_ELECTRO_400_NP: 244 case COMP::CAP_ELECTRO_500_NP: 245 case COMP::CAP_ELECTRO_600_NP: return 7; 246 case COMP::TRIM_VERT: 247 case COMP::TRIM_VERT_OFFSET: 248 case COMP::TRIM_VERT_OFFSET_WIDE: 249 case COMP::TRIM_FLAT: 250 case COMP::TRIM_FLAT_WIDE: 251 case COMP::TRIM_3006P: 252 case COMP::TRIM_3006W: 253 case COMP::TRIM_3006Y: 254 case COMP::TRIM_3329H: 255 case COMP::TRIM_3329P_DK9_RC: 256 case COMP::TRIM_3362F: 257 case COMP::TRIM_3362H: 258 case COMP::TRIM_3362P: 259 case COMP::TRIM_3362R: 260 case COMP::TRIM_3362U: 261 case COMP::TRIM_3362M: 262 case COMP::TRIM_3362S: 263 case COMP::TRIM_3362W: 264 case COMP::TRIM_3362X: 265 case COMP::TRIM_3362Z: return 8; 266 case COMP::DIODE: 267 case COMP::LED: return 10; 268 case COMP::TO92: 269 case COMP::TO18: 270 case COMP::TO39: 271 case COMP::TO220: return 11; 272 case COMP::DIP: return 12; 273 case COMP::DIP_RECTIFIER: return 13; 274 case COMP::SIP: return 14; 275 case COMP::STRIP_100: 276 case COMP::BLOCK_100: 277 case COMP::BLOCK_200: return 15; 278 case COMP::SWITCH_ST: 279 case COMP::SWITCH_DT: 280 case COMP::SWITCH_ST_DIP: 281 case COMP::SWITCH_BUTTON_4PIN: return 16; 282 case COMP::CRYSTAL: return 9; 283 case COMP::RELAY_HK19F: 284 case COMP::RELAY_HJR_4102: 285 case COMP::RELAY_FTR_B3C: 286 case COMP::RELAY_G2R_2: 287 case COMP::RELAY_G2R_2A: 288 case COMP::RELAY_G2RK_2: 289 case COMP::RELAY_G2RK_2A: 290 case COMP::RELAY_G3MB_202P: 291 case COMP::RELAY_JQC_3F_APPROX: 292 case COMP::RELAY_S1A050000: 293 case COMP::RELAY_TRCD: 294 case COMP::RELAY_DIP_4PIN: 295 case COMP::RELAY_DIP_8PIN: return 17; 296 case COMP::FUSE_HOLDER: return 18; 297 case COMP::MARK: return 100; 298 case COMP::VERO_NUMBER: return 200; 299 case COMP::VERO_LETTER: return 201; 300 default: return 1000; // Unhandled eType 301 } 302 } IsPlugCompTypes303 static bool IsPlug(const COMP& type) // true ==> Can plug gap between rows of IC pins 304 { 305 switch( type ) 306 { 307 case COMP::MARK: 308 case COMP::PAD: 309 case COMP::PAD_FLYINGWIRE: 310 case COMP::WIRE: 311 case COMP::RESISTOR: 312 case COMP::DIODE: 313 case COMP::CAP_CERAMIC: return true; 314 default: return false; 315 } 316 } GetFamilyStrCompTypes317 static std::string GetFamilyStr(const COMP& eType) // For grouping in the templates 318 { 319 switch( eType ) 320 { 321 case COMP::CAP_CERAMIC: 322 case COMP::CAP_FILM: 323 case COMP::CAP_FILM_WIDE: 324 case COMP::CAP_ELECTRO_200_NP: 325 case COMP::CAP_ELECTRO_250_NP: 326 case COMP::CAP_ELECTRO_300_NP: 327 case COMP::CAP_ELECTRO_400_NP: 328 case COMP::CAP_ELECTRO_500_NP: 329 case COMP::CAP_ELECTRO_600_NP: 330 case COMP::CAP_ELECTRO_200: 331 case COMP::CAP_ELECTRO_250: 332 case COMP::CAP_ELECTRO_300: 333 case COMP::CAP_ELECTRO_400: 334 case COMP::CAP_ELECTRO_500: 335 case COMP::CAP_ELECTRO_600: return "Capacitor"; 336 case COMP::TRIM_VERT: 337 case COMP::TRIM_VERT_OFFSET: 338 case COMP::TRIM_VERT_OFFSET_WIDE: 339 case COMP::TRIM_FLAT: 340 case COMP::TRIM_FLAT_WIDE: 341 case COMP::TRIM_3006P: 342 case COMP::TRIM_3006W: 343 case COMP::TRIM_3006Y: 344 case COMP::TRIM_3329H: 345 case COMP::TRIM_3329P_DK9_RC: 346 case COMP::TRIM_3362F: 347 case COMP::TRIM_3362H: 348 case COMP::TRIM_3362P: 349 case COMP::TRIM_3362R: 350 case COMP::TRIM_3362U: 351 case COMP::TRIM_3362M: 352 case COMP::TRIM_3362S: 353 case COMP::TRIM_3362W: 354 case COMP::TRIM_3362X: 355 case COMP::TRIM_3362Z: return "Trim-pot"; 356 case COMP::STRIP_100: 357 case COMP::BLOCK_100: 358 case COMP::BLOCK_200: return "Connector"; 359 case COMP::SWITCH_ST: 360 case COMP::SWITCH_DT: 361 case COMP::SWITCH_ST_DIP: 362 case COMP::SWITCH_BUTTON_4PIN: return "Switch"; 363 case COMP::RELAY_HK19F: 364 case COMP::RELAY_HJR_4102: 365 case COMP::RELAY_FTR_B3C: 366 case COMP::RELAY_G2R_2: 367 case COMP::RELAY_G2R_2A: 368 case COMP::RELAY_G2RK_2: 369 case COMP::RELAY_G2RK_2A: 370 case COMP::RELAY_G3MB_202P: 371 case COMP::RELAY_JQC_3F_APPROX: 372 case COMP::RELAY_S1A050000: 373 case COMP::RELAY_TRCD: 374 case COMP::RELAY_DIP_4PIN: 375 case COMP::RELAY_DIP_8PIN: return "Relay"; 376 default: return ""; 377 } 378 } GetDefaultPrefixStrCompTypes379 static std::string GetDefaultPrefixStr(const COMP& eType) // Prefix for name on creation 380 { 381 switch( eType ) 382 { 383 case COMP::MARK: return "Marker"; 384 case COMP::PAD: 385 case COMP::PAD_FLYINGWIRE: return "Pad"; 386 case COMP::WIRE: return "Wire"; 387 case COMP::RESISTOR: return "R"; 388 case COMP::INDUCTOR: return "L"; 389 case COMP::DIODE: 390 case COMP::LED: return "D"; 391 case COMP::CAP_CERAMIC: 392 case COMP::CAP_FILM: 393 case COMP::CAP_FILM_WIDE: 394 case COMP::CAP_ELECTRO_200_NP: 395 case COMP::CAP_ELECTRO_250_NP: 396 case COMP::CAP_ELECTRO_300_NP: 397 case COMP::CAP_ELECTRO_400_NP: 398 case COMP::CAP_ELECTRO_500_NP: 399 case COMP::CAP_ELECTRO_600_NP: 400 case COMP::CAP_ELECTRO_200: 401 case COMP::CAP_ELECTRO_250: 402 case COMP::CAP_ELECTRO_300: 403 case COMP::CAP_ELECTRO_400: 404 case COMP::CAP_ELECTRO_500: 405 case COMP::CAP_ELECTRO_600: return "C"; 406 case COMP::TO92: 407 case COMP::TO18: 408 case COMP::TO39: 409 case COMP::TO220: return "Q"; 410 case COMP::TRIM_VERT: 411 case COMP::TRIM_VERT_OFFSET: 412 case COMP::TRIM_VERT_OFFSET_WIDE: 413 case COMP::TRIM_FLAT: 414 case COMP::TRIM_FLAT_WIDE: 415 case COMP::TRIM_3006P: 416 case COMP::TRIM_3006W: 417 case COMP::TRIM_3006Y: 418 case COMP::TRIM_3329H: 419 case COMP::TRIM_3329P_DK9_RC: 420 case COMP::TRIM_3362F: 421 case COMP::TRIM_3362H: 422 case COMP::TRIM_3362P: 423 case COMP::TRIM_3362R: 424 case COMP::TRIM_3362U: 425 case COMP::TRIM_3362M: 426 case COMP::TRIM_3362S: 427 case COMP::TRIM_3362W: 428 case COMP::TRIM_3362X: 429 case COMP::TRIM_3362Z: return "RT"; 430 case COMP::SIP: 431 case COMP::DIP: 432 case COMP::DIP_RECTIFIER: return "IC"; 433 case COMP::STRIP_100: 434 case COMP::BLOCK_100: 435 case COMP::BLOCK_200: return "Connector"; 436 case COMP::SWITCH_ST: 437 case COMP::SWITCH_DT: 438 case COMP::SWITCH_ST_DIP: 439 case COMP::SWITCH_BUTTON_4PIN: return "SW"; 440 case COMP::CRYSTAL: return "XT"; 441 case COMP::RELAY_HK19F: 442 case COMP::RELAY_HJR_4102: 443 case COMP::RELAY_FTR_B3C: 444 case COMP::RELAY_G2R_2: 445 case COMP::RELAY_G2R_2A: 446 case COMP::RELAY_G2RK_2: 447 case COMP::RELAY_G2RK_2A: 448 case COMP::RELAY_G3MB_202P: 449 case COMP::RELAY_JQC_3F_APPROX: 450 case COMP::RELAY_S1A050000: 451 case COMP::RELAY_TRCD: 452 case COMP::RELAY_DIP_4PIN: 453 case COMP::RELAY_DIP_8PIN: return "SW"; 454 case COMP::FUSE_HOLDER: return "F"; 455 case COMP::CUSTOM: return ""; 456 case COMP::VERO_NUMBER: return "Vero Numbers"; 457 case COMP::VERO_LETTER: return "Vero Letters"; 458 default: return "INVALID"; // Unhandled eType 459 } 460 } AllowCustomPCBshapesCompTypes461 static bool AllowCustomPCBshapes(const COMP& eType) 462 { 463 switch(eType) 464 { 465 case COMP::RESISTOR: 466 case COMP::INDUCTOR: 467 case COMP::DIODE: 468 case COMP::DIP: 469 case COMP::DIP_RECTIFIER: 470 case COMP::RELAY_DIP_4PIN: 471 case COMP::RELAY_DIP_8PIN: return true; 472 default: return false; 473 } 474 } AllowTypeChangeCompTypes475 static bool AllowTypeChange(const COMP& eTypeA, const COMP& eTypeB) 476 { 477 const std::string prefixA = GetDefaultPrefixStr(eTypeA); 478 const std::string prefixB = GetDefaultPrefixStr(eTypeB); 479 if ( prefixA != prefixB ) return false; 480 if ( prefixA == std::string("Pad") ) return true; 481 if ( prefixA == std::string("D") ) return true; 482 if ( prefixA == std::string("C") ) return true; 483 if ( prefixA == std::string("RT") ) return true; 484 if ( prefixA == std::string("Strip") ) return true; 485 return false; 486 } GetPinSeparationCompTypes487 static int GetPinSeparation(const COMP& eType) // To handle change of component type for LEDs and electro-caps. 488 { 489 switch( eType ) 490 { 491 case COMP::LED: 492 case COMP::CAP_ELECTRO_200_NP: 493 case COMP::CAP_ELECTRO_200: 494 case COMP::CAP_ELECTRO_250_NP: 495 case COMP::CAP_ELECTRO_250: return 2; 496 case COMP::CAP_ELECTRO_300_NP: 497 case COMP::CAP_ELECTRO_300: 498 case COMP::CAP_ELECTRO_400_NP: 499 case COMP::CAP_ELECTRO_400: return 3; 500 case COMP::CAP_ELECTRO_500_NP: 501 case COMP::CAP_ELECTRO_500: 502 case COMP::CAP_ELECTRO_600_NP: 503 case COMP::CAP_ELECTRO_600: return 4; 504 default: return 0; 505 } 506 } GetTypeFromImportStrCompTypes507 static COMP GetTypeFromImportStr(const std::string& str) // Just for Import() 508 { 509 InitMapsCompTypeToStr(); 510 if ( str.empty() ) return COMP::INVALID; 511 for (const auto& mapObj : sm_mapCompTypeToImportStr) 512 if ( mapObj.second == str ) return mapObj.first; 513 return COMP::INVALID; 514 } GetMakeInstructionsCompTypes515 static std::string GetMakeInstructions(const COMP& eType, int& rows, int& cols) 516 { 517 switch( eType ) 518 { 519 case COMP::MARK : rows = 1; cols = 1; return "."; 520 case COMP::PAD : rows = 1; cols = 1; return "1"; 521 case COMP::PAD_FLYINGWIRE : rows = 1; cols = 1; return "1"; 522 case COMP::WIRE : rows = 1; cols = 3; return "1+2"; 523 case COMP::RESISTOR : rows = 1; cols = 5; return "1+++2"; 524 case COMP::INDUCTOR : rows = 1; cols = 5; return "1+++2"; 525 case COMP::DIODE : rows = 1; cols = 5; return "1+++2"; 526 case COMP::LED : rows = 1; cols = 2; return "12"; 527 case COMP::CAP_CERAMIC : 528 case COMP::CAP_FILM : rows = 1; cols = 3; return "1+2"; 529 case COMP::CAP_FILM_WIDE : rows = 3; cols = 3; return "+++1+2+++"; 530 case COMP::CAP_ELECTRO_200_NP : 531 case COMP::CAP_ELECTRO_200 : rows = 1; cols = 2; return "12"; 532 case COMP::CAP_ELECTRO_250_NP : 533 case COMP::CAP_ELECTRO_250 : rows = 3; cols = 2; return "++12++"; 534 case COMP::CAP_ELECTRO_300_NP : 535 case COMP::CAP_ELECTRO_300 : rows = 3; cols = 3; return "+++1+2+++"; 536 case COMP::CAP_ELECTRO_400_NP : 537 case COMP::CAP_ELECTRO_400 : rows = 5; cols = 5; return "..+...+++.+1+2+.+++...+.."; 538 case COMP::CAP_ELECTRO_500_NP : 539 case COMP::CAP_ELECTRO_500 : rows = 5; cols = 6; return ".++++..++++.+1++2+.++++..++++."; 540 case COMP::CAP_ELECTRO_600_NP : 541 case COMP::CAP_ELECTRO_600 : rows = 7; cols = 6; return "..++...++++.+++++++1++2+++++++.++++...++.."; 542 case COMP::TO92 : rows = 1; cols = 3; return "123"; 543 case COMP::TO18 : rows = 2; cols = 2; return "1+23"; 544 case COMP::TO39 : rows = 3; cols = 3; return "+++1+3+2+"; 545 case COMP::TO220 : rows = 1; cols = 3; return "123"; 546 case COMP::TRIM_VERT : rows = 1; cols = 3; return "123"; 547 case COMP::TRIM_VERT_OFFSET : rows = 2; cols = 3; return "+2+1+3"; 548 case COMP::TRIM_VERT_OFFSET_WIDE: rows = 3; cols = 3; return "+2++++1+3"; 549 case COMP::TRIM_FLAT : rows = 3; cols = 3; return "+2++++1+3"; 550 case COMP::TRIM_FLAT_WIDE : rows = 4; cols = 3; return "+2+++++++1+3"; 551 case COMP::TRIM_3006P : rows = 2; cols = 8; return "+1++++3+++++2+++"; 552 case COMP::TRIM_3006W : rows = 3; cols = 8; return "+1++++3+++++++++++++2+++"; 553 case COMP::TRIM_3006Y : rows = 2; cols = 8; return "1++++++3++++2+++"; 554 case COMP::TRIM_3329H : rows = 3; cols = 3; return ".+.12+.3."; 555 case COMP::TRIM_3329P_DK9_RC : rows = 3; cols = 3; return ".2.1+3.+."; 556 case COMP::TRIM_3362F : rows = 3; cols = 3; return "+2++++1+3"; 557 case COMP::TRIM_3362H : rows = 5; cols = 5; return "..+...+++.+12++.+3+...+.."; 558 case COMP::TRIM_3362P : rows = 3; cols = 3; return "+2+1+3+++"; 559 case COMP::TRIM_3362R : rows = 3; cols = 3; return "+++1+3+2+"; 560 case COMP::TRIM_3362U : rows = 3; cols = 3; return "+++123+++"; 561 case COMP::TRIM_3362M : rows = 3; cols = 3; return "+++123+++"; 562 case COMP::TRIM_3362S : rows = 2; cols = 3; return "+2+1+3"; 563 case COMP::TRIM_3362W : rows = 2; cols = 3; return "3+1+2+"; 564 case COMP::TRIM_3362X : rows = 2; cols = 3; return "1+3+2+"; 565 case COMP::TRIM_3362Z : rows = 2; cols = 3; return "+2+3+1"; 566 case COMP::SIP : rows = 1; cols = 8; return "12345678"; 567 case COMP::DIP : rows = 4; cols = 4; return "8765--------1234"; 568 case COMP::DIP_RECTIFIER : rows = 4; cols = 4; return "4++3--------1++2"; 569 case COMP::STRIP_100 : rows = 1; cols = 2; return "12"; 570 case COMP::BLOCK_100 : rows = 3; cols = 2; return "++12++"; 571 case COMP::BLOCK_200 : rows = 3; cols = 5; return ".+++..1+2..+++."; 572 case COMP::SWITCH_ST : rows = 3; cols = 1; return "1+2"; 573 case COMP::SWITCH_DT : rows = 5; cols = 1; return "1+2+3"; 574 case COMP::SWITCH_ST_DIP : rows = 4; cols = 2; return "12++++34"; 575 case COMP::SWITCH_BUTTON_4PIN : rows = 3; cols = 3; return "1+2+++3+4"; 576 case COMP::CRYSTAL : rows = 1; cols = 2; return "12"; 577 case COMP::RELAY_HK19F : rows = 4; cols = 8; return "8++7+6+5++++++++++++++++1++2+3+4"; 578 case COMP::RELAY_HJR_4102 : rows = 4; cols = 6; return "6+++54++++++++++++1+++23"; 579 case COMP::RELAY_FTR_B3C : rows = 3; cols = 5; return "8+765+++++1+234"; 580 case COMP::RELAY_G2R_2 : rows = 6; cols = 11; return "+++++++++++8+++++7+6+5++++++++++++++++++++++1+++++2+3+4+++++++++++"; 581 case COMP::RELAY_G2R_2A : rows = 6; cols = 11; return "+++++++++++6+++++++5+4++++++++++++++++++++++1+++++++2+3+++++++++++"; 582 case COMP::RELAY_G2RK_2 : rows = 6; cols = 11; return "+++++++++++A+9+++8+7+6++++++++++++++++++++++1+2+++3+4+5+++++++++++"; 583 case COMP::RELAY_G2RK_2A : rows = 6; cols = 11; return "+++++++++++8+7+++++6+5++++++++++++++++++++++1+2+++++3+4+++++++++++"; 584 case COMP::RELAY_G3MB_202P : rows = 2; cols = 9; return "+++++++++12+++3++4"; 585 case COMP::RELAY_JQC_3F_APPROX : rows = 6; cols = 7; return "1++++2+++++++++++++34+++++56+++++++7++++8+"; 586 case COMP::RELAY_S1A050000 : rows = 1; cols = 7; return "1+2+3+4"; 587 case COMP::RELAY_TRCD : rows = 6; cols = 8; return "1+++2+++++++++++++++++++++++++++++++++++3++++++4"; 588 case COMP::RELAY_DIP_4PIN : rows = 4; cols = 7; return "4+++++3+++++++++++++++1+++2+"; 589 case COMP::RELAY_DIP_8PIN : rows = 4; cols = 7; return "87+++65++++++++++++++12+++34"; 590 case COMP::FUSE_HOLDER : rows = 3; cols = 10; return "++++++++++1++++++++2++++++++++"; 591 case COMP::VERO_NUMBER : rows = 1; cols = 10; return ".........."; 592 case COMP::VERO_LETTER : rows = 1; cols = 10; return ".........."; 593 case COMP::CUSTOM : rows = 1; cols = 1; return "."; 594 case COMP::INVALID : rows = 0; cols = 0; return ""; 595 default: assert(0); rows = 0; cols = 0; return ""; // Unhandled eType 596 } 597 } GetDefaultPinLabelCompTypes598 static std::string GetDefaultPinLabel(size_t iPinIndex) 599 { 600 static char buffer[32]; 601 sprintf(buffer, "%d", static_cast<int>(iPinIndex+1)); // Pin numbers on screen start at 1 602 return buffer; 603 } GetDefaultPinAlignCompTypes604 static int GetDefaultPinAlign(size_t iPinIndex, size_t iNumPins, const COMP& eType) 605 { 606 switch( eType ) 607 { 608 case COMP::DIP: 609 case COMP::DIP_RECTIFIER: return ( 2 * iPinIndex < iNumPins ) ? Qt::AlignLeft : Qt::AlignRight; 610 default: return Qt::AlignHCenter; 611 } 612 } GetDefaultNumPinsCompTypes613 static int GetDefaultNumPins(const COMP& eType) 614 { 615 switch( eType ) 616 { 617 case COMP::MARK: return 0; 618 case COMP::PAD: 619 case COMP::PAD_FLYINGWIRE: return 1; 620 case COMP::WIRE: 621 case COMP::RESISTOR: 622 case COMP::INDUCTOR: 623 case COMP::DIODE: 624 case COMP::LED: 625 case COMP::CAP_CERAMIC: 626 case COMP::CAP_FILM: 627 case COMP::CAP_FILM_WIDE: 628 case COMP::CAP_ELECTRO_200_NP: 629 case COMP::CAP_ELECTRO_250_NP: 630 case COMP::CAP_ELECTRO_300_NP: 631 case COMP::CAP_ELECTRO_400_NP: 632 case COMP::CAP_ELECTRO_500_NP: 633 case COMP::CAP_ELECTRO_600_NP: 634 case COMP::CAP_ELECTRO_200: 635 case COMP::CAP_ELECTRO_250: 636 case COMP::CAP_ELECTRO_300: 637 case COMP::CAP_ELECTRO_400: 638 case COMP::CAP_ELECTRO_500: 639 case COMP::CAP_ELECTRO_600: return 2; 640 case COMP::TO92: 641 case COMP::TO18: 642 case COMP::TO39: 643 case COMP::TO220: 644 case COMP::TRIM_VERT: 645 case COMP::TRIM_VERT_OFFSET: 646 case COMP::TRIM_VERT_OFFSET_WIDE: 647 case COMP::TRIM_FLAT: 648 case COMP::TRIM_FLAT_WIDE: 649 case COMP::TRIM_3006P: 650 case COMP::TRIM_3006W: 651 case COMP::TRIM_3006Y: 652 case COMP::TRIM_3329H: 653 case COMP::TRIM_3329P_DK9_RC: 654 case COMP::TRIM_3362F: 655 case COMP::TRIM_3362H: 656 case COMP::TRIM_3362P: 657 case COMP::TRIM_3362R: 658 case COMP::TRIM_3362U: 659 case COMP::TRIM_3362M: 660 case COMP::TRIM_3362S: 661 case COMP::TRIM_3362W: 662 case COMP::TRIM_3362X: 663 case COMP::TRIM_3362Z: return 3; 664 case COMP::SIP: 665 case COMP::DIP: return 8; 666 case COMP::DIP_RECTIFIER: return 4; 667 case COMP::STRIP_100: 668 case COMP::BLOCK_100: 669 case COMP::BLOCK_200: return 2; 670 case COMP::SWITCH_ST: return 2; 671 case COMP::SWITCH_DT: return 3; 672 case COMP::SWITCH_ST_DIP: return 4; 673 case COMP::SWITCH_BUTTON_4PIN: return 4; 674 case COMP::CRYSTAL: return 2; 675 case COMP::RELAY_HK19F: return 8; 676 case COMP::RELAY_HJR_4102: return 6; 677 case COMP::RELAY_FTR_B3C: return 8; 678 case COMP::RELAY_G2R_2: return 8; 679 case COMP::RELAY_G2R_2A: return 6; 680 case COMP::RELAY_G2RK_2: return 10; 681 case COMP::RELAY_G2RK_2A: return 8; 682 case COMP::RELAY_G3MB_202P: return 4; 683 case COMP::RELAY_JQC_3F_APPROX: return 8; 684 case COMP::RELAY_S1A050000: return 4; 685 case COMP::RELAY_TRCD: return 4; 686 case COMP::RELAY_DIP_4PIN: return 4; 687 case COMP::RELAY_DIP_8PIN: return 8; 688 case COMP::FUSE_HOLDER: return 2; 689 case COMP::VERO_NUMBER: return 0; 690 case COMP::VERO_LETTER: return 0; 691 case COMP::CUSTOM: return 0; 692 default: return 0; // Unhandled eType 693 } 694 } GetMinNumPinsCompTypes695 static int GetMinNumPins(const COMP& eType) 696 { 697 switch( eType ) 698 { 699 case COMP::STRIP_100: 700 case COMP::BLOCK_100: 701 case COMP::BLOCK_200: 702 case COMP::SIP: return 1; 703 case COMP::DIP: 704 case COMP::SWITCH_ST: 705 case COMP::SWITCH_ST_DIP: return 2; 706 case COMP::SWITCH_DT: return 3; 707 default: return GetDefaultNumPins(eType); 708 } 709 } GetMaxNumPinsCompTypes710 static int GetMaxNumPins(const COMP& eType) 711 { 712 switch( eType ) 713 { 714 case COMP::STRIP_100: 715 case COMP::BLOCK_100: 716 case COMP::BLOCK_200: 717 case COMP::SIP: return 255; 718 case COMP::DIP: 719 case COMP::SWITCH_ST: 720 case COMP::SWITCH_ST_DIP: return 254; 721 case COMP::SWITCH_DT: return 255; // We're limited to (0 <= pinIndex <= 254) 722 default: return GetDefaultNumPins(eType); 723 } 724 } GetStretchIncrementCompTypes725 static int GetStretchIncrement(const COMP& eType) // For stretchable components 726 { 727 switch( eType ) 728 { 729 case COMP::SWITCH_ST: 730 case COMP::SWITCH_DT: // Growing a bulk switch increases its footprint by 2 columns instead of 1 731 case COMP::BLOCK_200: return 2; // As does a growing a strip with pitch of 2 squares 732 default: return 1; 733 } 734 } GetMinLengthCompTypes735 static int GetMinLength(const COMP& eType) // For stretchable components 736 { 737 switch( eType ) 738 { 739 case COMP::WIRE: 740 case COMP::DIODE: 741 case COMP::RESISTOR: 742 case COMP::INDUCTOR: 743 case COMP::CAP_CERAMIC: 744 case COMP::CAP_FILM: 745 case COMP::CAP_FILM_WIDE: return 2; 746 case COMP::STRIP_100: return GetMinNumPins(eType); 747 case COMP::BLOCK_100: return GetMinNumPins(eType); 748 case COMP::BLOCK_200: return GetMinNumPins(eType) * 2 + 1; 749 case COMP::SIP: return GetMinNumPins(eType); 750 case COMP::DIP: return GetMinNumPins(eType) / 2; 751 case COMP::SWITCH_ST: return GetMinNumPins(eType) / 2; 752 case COMP::SWITCH_DT: return GetMinNumPins(eType) / 3; 753 case COMP::SWITCH_ST_DIP: return GetMinNumPins(eType) / 2; 754 case COMP::VERO_NUMBER: return 1; 755 case COMP::VERO_LETTER: return 1; 756 default: assert(0); return 1; // Non-stretchable component 757 } 758 } GetMaxLengthCompTypes759 static int GetMaxLength(const COMP& eType) // For stretchable components 760 { 761 switch( eType ) 762 { 763 case COMP::WIRE: return INT_MAX; 764 case COMP::DIODE: 765 case COMP::RESISTOR: 766 case COMP::INDUCTOR: 767 case COMP::CAP_CERAMIC: 768 case COMP::CAP_FILM: 769 case COMP::CAP_FILM_WIDE: return 16; 770 case COMP::STRIP_100: return GetMaxNumPins(eType); 771 case COMP::BLOCK_100: return GetMaxNumPins(eType); 772 case COMP::BLOCK_200: return GetMaxNumPins(eType) * 2 + 1; 773 case COMP::SIP: return GetMaxNumPins(eType); 774 case COMP::DIP: return GetMaxNumPins(eType) / 2; 775 case COMP::SWITCH_ST: return GetMaxNumPins(eType) - 1; 776 case COMP::SWITCH_DT: return 2 * GetMaxNumPins(eType) / 3 - 1; 777 case COMP::SWITCH_ST_DIP: return GetMaxNumPins(eType) / 2; 778 case COMP::VERO_NUMBER: return 255; 779 case COMP::VERO_LETTER: return 255; 780 default: assert(0); return 1; // Non-stretchable component 781 } 782 } 783 private: 784 static std::map<COMP, std::string> sm_mapCompTypeToTypeStr; // Mapping of COMP enum to Type strings 785 static std::map<COMP, std::string> sm_mapCompTypeToImportStr; // Import mapping of COMP enum to strings 786 static std::list<COMP> sm_listCompTypes; // Ordered by appearance in GUI 787 }; 788