001package jmri.jmrit.throttle; 002 003import java.awt.event.KeyEvent; 004 005import javax.swing.KeyStroke; 006 007import org.jdom2.Element; 008import org.slf4j.Logger; 009import org.slf4j.LoggerFactory; 010 011/** 012 * A class to store JMRI throttles keyboard shortcuts 013 * 014 * @author Lionel Jeanson - 2021 015 * 016 */ 017public class ThrottlesPreferencesWindowKeyboardControls implements Cloneable { 018 019 // speed multiplier 020 private float moreSpeedMultiplier = 5f; 021 022 // 023 // shortcuts stored as arrays of pairs [modifier][key] 024 // 025 // all bellow defaults are extracted from previous existing code 026 // 027 // moving through throttle windows 028 private int[][] nextThrottleWindowKeys = { 029 {0,KeyEvent.VK_INSERT} 030 }; 031 private int[][] prevThrottleWindowKeys = { 032 {0,KeyEvent.VK_DELETE} 033 }; 034 // moving through 1 throttle window frames 035 private int[][] nextThrottleFrameKeys = { 036 {0,KeyEvent.VK_END} 037 }; 038 private int[][] prevThrottleFrameKeys = { 039 {0,KeyEvent.VK_HOME} 040 }; 041 // moving through running throttle frames 042 private int[][] nextRunThrottleFrameKeys = { 043 {KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_END} 044 }; 045 private int[][] prevRunThrottleFrameKeys = { 046 {KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_HOME} 047 }; 048 049 // moving through internal windows 050 private int[][] nextThrottleInternalWindowKeys = { 051 {0,KeyEvent.VK_K}, 052 {0,KeyEvent.VK_TAB} 053 }; 054 private int[][] prevThrottleInternalWindowKeys = { 055 {0,KeyEvent.VK_L}, 056 {KeyEvent.SHIFT_DOWN_MASK, KeyEvent.VK_TAB} 057 }; 058 059 // select internal window 060 private int[][] moveToControlPanelKeys = { 061 {0,KeyEvent.VK_C} 062 }; 063 private int[][] moveToFunctionPanelKeys = { 064 {0,KeyEvent.VK_F} 065 }; 066 private int[][] moveToAddressPanelKeys= { 067 {0,KeyEvent.VK_A} 068 }; 069 070 071 // Speed 072 private int[][] reverseKeys = { 073 {0,KeyEvent.VK_DOWN} // Down arrow 074 }; 075 private int[][] forwardKeys = { 076 {0,KeyEvent.VK_UP} // Up arrow 077 }; 078 private int[][] switchDirectionKeys = { 079 }; 080 081 private int[][] idleKeys = { 082 {0,KeyEvent.VK_MULTIPLY}, // numpad * 083 {0,KeyEvent.VK_SPACE} 084 }; 085 private int[][] stopKeys= { 086 {0,KeyEvent.VK_DIVIDE}, // numpad / 087 {0,KeyEvent.VK_ESCAPE} 088 }; 089 090 private int[][] accelerateKeys = { 091 {0,KeyEvent.VK_ADD}, // numpad + 092 {0,KeyEvent.VK_LEFT} 093 }; 094 private int[][] decelerateKeys = { 095 {0,KeyEvent.VK_SUBTRACT}, // numpad -; 096 {0,KeyEvent.VK_RIGHT} 097 }; 098 private int[][] accelerateMoreKeys = { 099 {0,KeyEvent.VK_PAGE_UP}, 100 {KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_LEFT} 101 }; 102 private int[][] decelerateMoreKeys = { 103 {0,KeyEvent.VK_PAGE_DOWN}, 104 {KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_RIGHT} 105 }; 106 107 // function buttons 108 private int[][][] functionsKeys = { 109 {{0,KeyEvent.VK_NUMPAD0}}, // F0 110 {{0,KeyEvent.VK_F1},{0,KeyEvent.VK_NUMPAD1}}, // F1 111 {{0,KeyEvent.VK_F2},{0,KeyEvent.VK_NUMPAD2}}, // F2 112 {{0,KeyEvent.VK_F3},{0,KeyEvent.VK_NUMPAD3}}, // F3 113 {{0,KeyEvent.VK_F4},{0,KeyEvent.VK_NUMPAD4}}, // F4 114 {{0,KeyEvent.VK_F5},{0,KeyEvent.VK_NUMPAD5}}, // F5 115 {{0,KeyEvent.VK_F6},{0,KeyEvent.VK_NUMPAD6}}, // F6 116 {{0,KeyEvent.VK_F7},{0,KeyEvent.VK_NUMPAD7}}, // F7 117 {{0,KeyEvent.VK_F8},{0,KeyEvent.VK_NUMPAD8}}, // F8 118 {{0,KeyEvent.VK_F9},{0,KeyEvent.VK_NUMPAD9}}, // F9 119 {{0,KeyEvent.VK_F10},{0,KeyEvent.VK_DECIMAL},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_NUMPAD0}}, // F10 120 {{0,KeyEvent.VK_F11},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_F1},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_NUMPAD1}}, // F11 121 {{0,KeyEvent.VK_F12},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_F2},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_NUMPAD2}}, // F12 122 {{0,KeyEvent.VK_F13},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_F3},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_NUMPAD3}}, // F13 123 {{0,KeyEvent.VK_F14},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_F4},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_NUMPAD4}}, // F14 124 {{0,KeyEvent.VK_F15},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_F5},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_NUMPAD5}}, // F15 125 {{0,KeyEvent.VK_F16},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_F6},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_NUMPAD6}}, // F16 126 {{0,KeyEvent.VK_F17},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_F7},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_NUMPAD7}}, // F17 127 {{0,KeyEvent.VK_F18},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_F8},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_NUMPAD8}}, // F18 128 {{0,KeyEvent.VK_F19},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_F9},{KeyEvent.SHIFT_DOWN_MASK,KeyEvent.VK_NUMPAD9}}, // F19 129 {{0,KeyEvent.VK_F20},{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_F10},{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_NUMPAD0}}, // F20 130 {{0,KeyEvent.VK_F21},{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_F1},{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_NUMPAD1}}, // F21 131 {{0,KeyEvent.VK_F22},{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_F2},{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_NUMPAD2}}, // F22 132 {{0,KeyEvent.VK_F23},{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_F3},{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_NUMPAD3}}, // F23 133 {{0,KeyEvent.VK_F24},{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_F4},{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_NUMPAD4}}, // F24 134 {{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_F5},{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_NUMPAD5}}, // F25 135 {{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_F6},{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_NUMPAD6}}, // F26 136 {{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_F7},{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_NUMPAD7}}, // F27 137 {{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_F8},{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_NUMPAD8}} // F28 138 // simply add more lines for more functions controls... 139 // {{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_F9},{KeyEvent.CTRL_DOWN_MASK,KeyEvent.VK_NUMPAD9}}, // F29 140 }; 141 142 /** 143 * @return the nextThrottleWindowKeys 144 */ 145 public int[][] getNextThrottleWindowKeys() { 146 return nextThrottleWindowKeys; 147 } 148 149 /** 150 * @return the prevThrottleWindowKeys 151 */ 152 public int[][] getPrevThrottleWindowKeys() { 153 return prevThrottleWindowKeys; 154 } 155 156 /** 157 * @return the nextThrottleFrameKeys 158 */ 159 public int[][] getNextThrottleFrameKeys() { 160 return nextThrottleFrameKeys; 161 } 162 163 /** 164 * @return the prevThrottleFrameKeys 165 */ 166 public int[][] getPrevThrottleFrameKeys() { 167 return prevThrottleFrameKeys; 168 } 169 170 /** 171 * @return the nextRunThrottleFrameKeys 172 */ 173 public int[][] getNextRunThrottleFrameKeys() { 174 return nextRunThrottleFrameKeys; 175 } 176 177 /** 178 * @return the prevRunThrottleFrameKeys 179 */ 180 public int[][] getPrevRunThrottleFrameKeys() { 181 return prevRunThrottleFrameKeys; 182 } 183 184 /** 185 * @return the nextThrottleInternalWindowKeys 186 */ 187 public int[][] getNextThrottleInternalWindowKeys() { 188 return nextThrottleInternalWindowKeys; 189 } 190 191 /** 192 * @return the prevThrottleInternalWindowKeys 193 */ 194 public int[][] getPrevThrottleInternalWindowKeys() { 195 return prevThrottleInternalWindowKeys; 196 } 197 198 /** 199 * @return the moveToControlPanelKeys 200 */ 201 public int[][] getMoveToControlPanelKeys() { 202 return moveToControlPanelKeys; 203 } 204 205 /** 206 * @return the moveToFunctionPanelKeys 207 */ 208 public int[][] getMoveToFunctionPanelKeys() { 209 return moveToFunctionPanelKeys; 210 } 211 212 /** 213 * @return the moveToAddressPanelKeys 214 */ 215 public int[][] getMoveToAddressPanelKeys() { 216 return moveToAddressPanelKeys; 217 } 218 219 /** 220 * @return the reverseKeys 221 */ 222 public int[][] getReverseKeys() { 223 return reverseKeys; 224 } 225 226 /** 227 * @return the forwardKeys 228 */ 229 public int[][] getForwardKeys() { 230 return forwardKeys; 231 } 232 233 /** 234 * @return the switchDirectionKeys 235 */ 236 public int[][] getSwitchDirectionKeys() { 237 return switchDirectionKeys; 238 } 239 240 /** 241 * @return the idleKeys 242 */ 243 public int[][] getIdleKeys() { 244 return idleKeys; 245 } 246 247 /** 248 * @return the stopKeys 249 */ 250 public int[][] getStopKeys() { 251 return stopKeys; 252 } 253 254 /** 255 * @return the accelerateKeys 256 */ 257 public int[][] getAccelerateKeys() { 258 return accelerateKeys; 259 } 260 261 /** 262 * @return the decelerateKeys 263 */ 264 public int[][] getDecelerateKeys() { 265 return decelerateKeys; 266 } 267 268 /** 269 * @return the accelerateMoreKeys 270 */ 271 public int[][] getAccelerateMoreKeys() { 272 return accelerateMoreKeys; 273 } 274 275 /** 276 * @return the decelerateMoreKeys 277 */ 278 public int[][] getDecelerateMoreKeys() { 279 return decelerateMoreKeys; 280 } 281 282 /** 283 * @param fn function number 284 * @return the functionsKeys 285 */ 286 public int[][] getFunctionsKeys(int fn) { 287 return functionsKeys[fn]; 288 } 289 290 public KeyStroke[] getKeyStrokes(String evtString) { 291 int [][] keys = null; 292 boolean onKeyRelease = true; 293 switch (evtString) { 294 // Throttle commands 295 case "accelerate" : keys = getAccelerateKeys(); onKeyRelease = false; break; 296 case "decelerate" : keys = getDecelerateKeys(); onKeyRelease = false; break; 297 case "accelerateMore" : keys = getAccelerateMoreKeys(); onKeyRelease = false; break; 298 case "decelerateMore" : keys = getDecelerateMoreKeys(); onKeyRelease = false; break; 299 case "idle" : keys = getIdleKeys(); break; 300 case "stop" : keys = getStopKeys(); break; 301 case "forward" : keys = getForwardKeys(); break; 302 case "reverse" : keys = getReverseKeys(); break; 303 case "switchDirection" : keys = getSwitchDirectionKeys(); break; 304 // Throttle inner window cycling 305 case "nextJInternalFrame" : keys = getNextThrottleInternalWindowKeys(); break; 306 case "previousJInternalFrame" : keys = getPrevThrottleInternalWindowKeys(); break; 307 case "showControlPanel" : keys = getMoveToControlPanelKeys(); break; 308 case "showFunctionPanel" : keys = getMoveToFunctionPanelKeys(); break; 309 case "showAddressPanel" : keys = getMoveToAddressPanelKeys(); break; 310 // Throttle frames 311 case "nextThrottleFrame" : keys = getNextThrottleFrameKeys(); break; 312 case "previousThrottleFrame" : keys = getPrevThrottleFrameKeys(); break; 313 case "nextRunningThrottleFrame" : keys = getNextRunThrottleFrameKeys(); break; 314 case "previousRunningThrottleFrame" : keys = getPrevRunThrottleFrameKeys(); break; 315 // Throttle windows 316 case "nextThrottleWindow" : keys = getNextThrottleWindowKeys(); break; 317 case "previousThrottleWindow" : keys = getPrevThrottleWindowKeys(); break; 318 default: 319 } 320 // function buttons 321 if (evtString.matches("fn_.*_.*")) { 322 String[]tokens = evtString.split("_"); 323 keys = functionsKeys[Integer.parseInt(tokens[1])]; 324 if("Pressed".equals(tokens[2])) { 325 onKeyRelease = false; 326 } 327 } 328 if (keys == null) { 329 return new KeyStroke[0]; 330 } 331 KeyStroke[] ks = new KeyStroke[keys.length]; 332 for (int i = 0 ; i < ks.length; i++) { 333 ks[i] = KeyStroke.getKeyStroke(keys[i][1], keys[i][0], onKeyRelease); 334 } 335 return ks; 336 } 337 338 /** 339 * @return the number of functions shortcuts 340 */ 341 public int getNbFunctionsKeys() { 342 return functionsKeys.length; 343 } 344 345 /** 346 * @param fn the function numbers 347 * @param aFunctionsKeys the functionsKeys to set 348 */ 349 public void setFunctionsKeys(int fn, int[][] aFunctionsKeys) { 350 this.functionsKeys[fn] = aFunctionsKeys; 351 } 352 353 /** 354 * @return the moreSpeedMultiplier 355 */ 356 public float getMoreSpeedMultiplier() { 357 return moreSpeedMultiplier; 358 } 359 360 /** 361 * @param moreSpeedMultiplier the moreSpeedMultiplier to set 362 */ 363 public void setMoreSpeedMultiplier(float moreSpeedMultiplier) { 364 this.moreSpeedMultiplier = moreSpeedMultiplier; 365 } 366 367 /** 368 * @param nextThrottleWindowKeys the nextThrottleWindowKeys to set 369 */ 370 public void setNextThrottleWindowKeys(int[][] nextThrottleWindowKeys) { 371 this.nextThrottleWindowKeys = nextThrottleWindowKeys; 372 } 373 374 /** 375 * @param prevThrottleWindowKeys the prevThrottleWindowKeys to set 376 */ 377 public void setPrevThrottleWindowKeys(int[][] prevThrottleWindowKeys) { 378 this.prevThrottleWindowKeys = prevThrottleWindowKeys; 379 } 380 381 /** 382 * @param nextTrottleFrameKeys the nextThrottleFrameKeys to set 383 */ 384 public void setNextTrottleFrameKeys(int[][] nextTrottleFrameKeys) { 385 this.nextThrottleFrameKeys = nextTrottleFrameKeys; 386 } 387 388 /** 389 * @param prevThrottleFrameKeys the prevThrottleFrameKeys to set 390 */ 391 public void setPrevThrottleFrameKeys(int[][] prevThrottleFrameKeys) { 392 this.prevThrottleFrameKeys = prevThrottleFrameKeys; 393 } 394 395 /** 396 * @param nextRunThrottleFrameKeys the nextRunThrottleFrameKeys to set 397 */ 398 public void setNextRunThrottleFrameKeys(int[][] nextRunThrottleFrameKeys) { 399 this.nextRunThrottleFrameKeys = nextRunThrottleFrameKeys; 400 } 401 402 /** 403 * @param prevRunThrottleFrameKeys the prevRunThrottleFrameKeys to set 404 */ 405 public void setPrevRunThrottleFrameKeys(int[][] prevRunThrottleFrameKeys) { 406 this.prevRunThrottleFrameKeys = prevRunThrottleFrameKeys; 407 } 408 409 /** 410 * @param nextThrottleInternalWindowKeys the nextThrottleInternalWindowKeys to set 411 */ 412 public void setNextThrottleInternalWindowKeys(int[][] nextThrottleInternalWindowKeys) { 413 this.nextThrottleInternalWindowKeys = nextThrottleInternalWindowKeys; 414 } 415 416 /** 417 * @param prevThrottleInternalWindowKeys the prevThrottleInternalWindowKeys to set 418 */ 419 public void setPrevThrottleInternalWindowKeys(int[][] prevThrottleInternalWindowKeys) { 420 this.prevThrottleInternalWindowKeys = prevThrottleInternalWindowKeys; 421 } 422 423 /** 424 * @param moveToControlPanelKeys the moveToControlPanelKeys to set 425 */ 426 public void setMoveToControlPanelKeys(int[][] moveToControlPanelKeys) { 427 this.moveToControlPanelKeys = moveToControlPanelKeys; 428 } 429 430 /** 431 * @param moveToFunctionPanelKeys the moveToFunctionPanelKeys to set 432 */ 433 public void setMoveToFunctionPanelKeys(int[][] moveToFunctionPanelKeys) { 434 this.moveToFunctionPanelKeys = moveToFunctionPanelKeys; 435 } 436 437 /** 438 * @param moveToAddressPanelKeys the moveToAddressPanelKeys to set 439 */ 440 public void setMoveToAddressPanelKeys(int[][] moveToAddressPanelKeys) { 441 this.moveToAddressPanelKeys = moveToAddressPanelKeys; 442 } 443 444 /** 445 * @param reverseKeys the reverseKeys to set 446 */ 447 public void setReverseKeys(int[][] reverseKeys) { 448 this.reverseKeys = reverseKeys; 449 } 450 451 /** 452 * @param forwardKeys the forwardKeys to set 453 */ 454 public void setForwardKeys(int[][] forwardKeys) { 455 this.forwardKeys = forwardKeys; 456 } 457 458 /** 459 * @param switchDirectionKeys the switchDirectionKeys to set 460 */ 461 public void setSwitchDirectionKeys(int[][] switchDirectionKeys) { 462 this.switchDirectionKeys = switchDirectionKeys; 463 } 464 465 /** 466 * @param idleKeys the idleKeys to set 467 */ 468 public void setIdleKeys(int[][] idleKeys) { 469 this.idleKeys = idleKeys; 470 } 471 472 /** 473 * @param stopKeys the stopKeys to set 474 */ 475 public void setStopKeys(int[][] stopKeys) { 476 this.stopKeys = stopKeys; 477 } 478 479 /** 480 * @param accelerateKeys the accelerateKeys to set 481 */ 482 public void setAccelerateKeys(int[][] accelerateKeys) { 483 this.accelerateKeys = accelerateKeys; 484 } 485 486 /** 487 * @param decelerateKeys the decelerateKeys to set 488 */ 489 public void setDecelerateKeys(int[][] decelerateKeys) { 490 this.decelerateKeys = decelerateKeys; 491 } 492 493 /** 494 * @param accelerateMoreKeys the accelerateMoreKeys to set 495 */ 496 public void setAccelerateMoreKeys(int[][] accelerateMoreKeys) { 497 this.accelerateMoreKeys = accelerateMoreKeys; 498 } 499 500 /** 501 * @param decelerateMoreKeys the decelerateMoreKeys to set 502 */ 503 public void setDecelerateMoreKeys(int[][] decelerateMoreKeys) { 504 this.decelerateMoreKeys = decelerateMoreKeys; 505 } 506 507 @Override 508 public ThrottlesPreferencesWindowKeyboardControls clone() throws CloneNotSupportedException { 509 ThrottlesPreferencesWindowKeyboardControls ret = (ThrottlesPreferencesWindowKeyboardControls) super.clone(); 510 511 ret.moreSpeedMultiplier = this.moreSpeedMultiplier; 512 ret.nextThrottleWindowKeys = clone(this.nextThrottleWindowKeys); 513 ret.prevThrottleWindowKeys = clone(this.prevThrottleWindowKeys); 514 ret.nextThrottleFrameKeys = clone(this.nextThrottleFrameKeys); 515 ret.prevThrottleFrameKeys = clone(this.prevThrottleFrameKeys); 516 ret.nextRunThrottleFrameKeys = clone(this.nextRunThrottleFrameKeys); 517 ret.prevRunThrottleFrameKeys = clone(this.prevRunThrottleFrameKeys); 518 ret.nextThrottleInternalWindowKeys = clone(this.nextThrottleInternalWindowKeys); 519 ret.prevThrottleInternalWindowKeys = clone(this.prevThrottleInternalWindowKeys); 520 ret.moveToControlPanelKeys = clone(this.moveToControlPanelKeys); 521 ret.moveToFunctionPanelKeys = clone(this.moveToFunctionPanelKeys); 522 ret.moveToAddressPanelKeys = clone(this.moveToAddressPanelKeys); 523 ret.reverseKeys = clone(this.reverseKeys); 524 ret.forwardKeys = clone(this.forwardKeys); 525 ret.switchDirectionKeys = clone(this.switchDirectionKeys); 526 ret.idleKeys = clone(this.idleKeys); 527 ret.stopKeys = clone(this.stopKeys); 528 ret.accelerateKeys = clone(this.accelerateKeys); 529 ret.decelerateKeys = clone(this.decelerateKeys); 530 ret.accelerateMoreKeys = clone(this.accelerateMoreKeys); 531 ret.decelerateMoreKeys = clone(this.decelerateMoreKeys); 532 ret.functionsKeys = new int[this.functionsKeys.length][0][0]; 533 for (int i=0; i<this.functionsKeys.length; i++) { 534 ret.functionsKeys[i] = clone(this.functionsKeys[i]); 535 } 536 return ret; 537 } 538 539 private int[][] clone(int[][] from) { 540 int[][] to = new int[from.length][2]; 541 for (int i=0;i<from.length;i++) { 542 to[i][0] = from[i][0]; 543 to[i][1] = from[i][1]; 544 } 545 return to; 546 } 547 548 private Element getControlXml(String eltname, int[][] controls) { 549 java.util.ArrayList<Element> children = new java.util.ArrayList<>(controls.length); 550 for (int i=0;i<controls.length;i++) { 551 org.jdom2.Element e = new org.jdom2.Element("ksc-"+i); 552 e.setAttribute("m",""+controls[i][0]); 553 e.setAttribute("k",""+controls[i][1]); 554 children.add(e); 555 } 556 org.jdom2.Element e = new org.jdom2.Element(eltname); 557 e.setContent(children); 558 return e; 559 } 560 561 Element store() { 562 java.util.ArrayList<Element> children = new java.util.ArrayList<>(10); 563 children.add( getControlXml("nextThrottleWindowKeys", nextThrottleWindowKeys)); 564 children.add( getControlXml("prevThrottleWindowKeys", prevThrottleWindowKeys)); 565 children.add( getControlXml("nextThrottleFrameKeys", nextThrottleFrameKeys)); 566 children.add( getControlXml("prevThrottleFrameKeys", prevThrottleFrameKeys)); 567 children.add( getControlXml("nextRunThrottleFrameKeys", nextRunThrottleFrameKeys)); 568 children.add( getControlXml("prevRunThrottleFrameKeys", prevRunThrottleFrameKeys)); 569 children.add( getControlXml("nextThrottleInternalWindowKeys", nextThrottleInternalWindowKeys)); 570 children.add( getControlXml("prevThrottleInternalWindowKeys", prevThrottleInternalWindowKeys)); 571 children.add( getControlXml("moveToControlPanelKeys", moveToControlPanelKeys)); 572 children.add( getControlXml("moveToFunctionPanelKeys", moveToFunctionPanelKeys)); 573 children.add( getControlXml("moveToAddressPanelKeys", moveToAddressPanelKeys)); 574 children.add( getControlXml("reverseKeys", reverseKeys)); 575 children.add( getControlXml("forwardKeys", forwardKeys)); 576 children.add( getControlXml("switchDirectionKeys", switchDirectionKeys)); 577 children.add( getControlXml("idleKeys", idleKeys)); 578 children.add( getControlXml("stopKeys", stopKeys)); 579 children.add( getControlXml("accelerateKeys", accelerateKeys)); 580 children.add( getControlXml("decelerateKeys", decelerateKeys)); 581 children.add( getControlXml("accelerateMoreKeys", accelerateMoreKeys)); 582 children.add( getControlXml("decelerateMoreKeys", decelerateMoreKeys)); 583 for (int i=0;i<functionsKeys.length;i++) { 584 children.add( getControlXml("functionsKeys-"+i, functionsKeys[i])); 585 } 586 org.jdom2.Element e = new org.jdom2.Element("throttlesControls"); 587 e.setAttribute("moreSpeedMultiplier",""+moreSpeedMultiplier); 588 e.setContent(children); 589 return e; 590 } 591 592 private int[][] createControlFromXml(Element child) { 593 int[][] ret = new int[child.getChildren().size()][2]; 594 int i=0; 595 for (Element e : child.getChildren()) { 596 ret[i][0] = Integer.parseInt(e.getAttributeValue("m")); 597 ret[i][1] = Integer.parseInt(e.getAttributeValue("k")); 598 i++; 599 } 600 601 return ret; 602 } 603 604 public void load(org.jdom2.Element e) { 605 if ((e == null) || (e.getChildren().isEmpty())) { 606 return; 607 } 608 try { 609 nextThrottleWindowKeys = createControlFromXml(e.getChild("nextThrottleWindowKeys")); 610 prevThrottleWindowKeys = createControlFromXml(e.getChild("prevThrottleWindowKeys")); 611 nextThrottleFrameKeys = createControlFromXml(e.getChild("nextThrottleFrameKeys")); 612 prevThrottleFrameKeys = createControlFromXml(e.getChild("prevThrottleFrameKeys")); 613 nextRunThrottleFrameKeys = createControlFromXml(e.getChild("nextRunThrottleFrameKeys")); 614 prevRunThrottleFrameKeys = createControlFromXml(e.getChild("prevRunThrottleFrameKeys")); 615 nextThrottleInternalWindowKeys = createControlFromXml(e.getChild("nextThrottleInternalWindowKeys")); 616 prevThrottleInternalWindowKeys = createControlFromXml(e.getChild("prevThrottleInternalWindowKeys")); 617 moveToControlPanelKeys = createControlFromXml(e.getChild("moveToControlPanelKeys")); 618 moveToFunctionPanelKeys = createControlFromXml(e.getChild("moveToFunctionPanelKeys")); 619 moveToAddressPanelKeys = createControlFromXml(e.getChild("moveToAddressPanelKeys")); 620 reverseKeys = createControlFromXml(e.getChild("reverseKeys")); 621 forwardKeys = createControlFromXml(e.getChild("forwardKeys")); 622 switchDirectionKeys = createControlFromXml(e.getChild("switchDirectionKeys")); 623 idleKeys = createControlFromXml(e.getChild("idleKeys")); 624 stopKeys = createControlFromXml(e.getChild("stopKeys")); 625 accelerateKeys = createControlFromXml(e.getChild("accelerateKeys")); 626 decelerateKeys = createControlFromXml(e.getChild("decelerateKeys")); 627 accelerateMoreKeys = createControlFromXml(e.getChild("accelerateMoreKeys")); 628 decelerateMoreKeys = createControlFromXml(e.getChild("decelerateMoreKeys")); 629 for (int i=0;i<functionsKeys.length;i++) { 630 functionsKeys[i] = createControlFromXml(e.getChild("functionsKeys-"+i)); 631 } 632 moreSpeedMultiplier = Float.parseFloat(e.getAttributeValue("moreSpeedMultiplier")); 633 } catch (NumberFormatException exc) { 634 log.error("Error while restoring thottle controls from xml : {}", exc.getMessage()); 635 } 636 637 } 638 639 private final static Logger log = LoggerFactory.getLogger(ThrottlesPreferencesWindowKeyboardControls.class); 640}