1: //========================================================================================
     2: //  ButtonFunction.java
     3: //    en:F11/F12 and button function assignments
     4: //    ja:F11/F12およびボタン機能割り当て
     5: //  Copyright (C) 2003-2025 Makoto Kamada
     6: //
     7: //  This file is part of the XEiJ (X68000 Emulator in Java).
     8: //  You can use, modify and redistribute the XEiJ if the conditions are met.
     9: //  Read the XEiJ License for more details.
    10: //  https://stdkmd.net/xeij/
    11: //========================================================================================
    12: 
    13: package xeij;
    14: 
    15: import java.awt.event.*;  //ActionListener
    16: import java.util.*;  //ArrayList
    17: import javax.swing.*;  //JMenu
    18: 
    19: //class ButtonFunction
    20: //  F11/F12およびボタン機能割り当て
    21: public class ButtonFunction {
    22: 
    23: 
    24: 
    25:   public static enum Button {
    26:     F11 {
    27:       @Override String en () {
    28:         return "F11 key";
    29:       }
    30:       @Override String ja () {
    31:         return "F11 キー";
    32:       }
    33:       @Override String paramK () {
    34:         return "f11key";
    35:       }
    36:     },
    37:     F12 {
    38:       @Override String en () {
    39:         return "F12 key";
    40:       }
    41:       @Override String ja () {
    42:         return "F12 キー";
    43:       }
    44:       @Override String paramK () {
    45:         return "f12key";
    46:       }
    47:     },
    48:     WHEEL {
    49:       @Override String en () {
    50:         return "Wheel button";
    51:       }
    52:       @Override String ja () {
    53:         return "ホイールボタン";
    54:       }
    55:       @Override String paramK () {
    56:         return "wheel";
    57:       }
    58:     },
    59:     WHEELUP {
    60:       @Override String en () {
    61:         return "Wheel scroll up";
    62:       }
    63:       @Override String ja () {
    64:         return "ホイールスクロールアップ";
    65:       }
    66:       @Override String paramK () {
    67:         return "wheelup";
    68:       }
    69:     },
    70:     WHEELDOWN {
    71:       @Override String en () {
    72:         return "Wheel scroll down";
    73:       }
    74:       @Override String ja () {
    75:         return "ホイールスクロールダウン";
    76:       }
    77:       @Override String paramK () {
    78:         return "wheeldown";
    79:       }
    80:     },
    81:     BUTTON4 {
    82:       @Override String en () {
    83:         return "Button 4";
    84:       }
    85:       @Override String ja () {
    86:         return "ボタン 4";
    87:       }
    88:       @Override String paramK () {
    89:         return "button4";
    90:       }
    91:     },
    92:     BUTTON5 {
    93:       @Override String en () {
    94:         return "Button 5";
    95:       }
    96:       @Override String ja () {
    97:         return "ボタン 5";
    98:       }
    99:       @Override String paramK () {
   100:         return "button5";
   101:       }
   102:     };
   103:     abstract String en ();
   104:     abstract String ja ();
   105:     abstract String paramK ();
   106:   }  //enum Button
   107: 
   108:   static final Button[] BUTTON_ARRAY = Button.values ();
   109:   static final int BUTTONS = BUTTON_ARRAY.length;
   110: 
   111: 
   112: 
   113:   public static enum Modifier {
   114:     ONLY {
   115:       @Override int mask () {
   116:         return 0;
   117:       }
   118:       @Override String paramK () {
   119:         return "";
   120:       }
   121:       @Override String en () {
   122:         return "Only";
   123:       }
   124:       @Override String ja () {
   125:         return "単独";
   126:       }
   127:     },
   128:     SHIFT {
   129:       @Override int mask () {
   130:         return InputEvent.SHIFT_DOWN_MASK;
   131:       }
   132:       @Override String paramK () {
   133:         return "shift";
   134:       }
   135:       @Override String en () {
   136:         return "Shift";
   137:       }
   138:       @Override String ja () {
   139:         return "Shift";
   140:       }
   141:     },
   142:     CTRL {
   143:       @Override int mask () {
   144:         return InputEvent.CTRL_DOWN_MASK;
   145:       }
   146:       @Override String paramK () {
   147:         return "ctrl";
   148:       }
   149:       @Override String en () {
   150:         return "Ctrl";
   151:       }
   152:       @Override String ja () {
   153:         return "Ctrl";
   154:       }
   155:     },
   156:     ALT {
   157:       @Override int mask () {
   158:         return InputEvent.ALT_DOWN_MASK;
   159:       }
   160:       @Override String paramK () {
   161:         return "alt";
   162:       }
   163:       @Override String en () {
   164:         return "Alt";
   165:       }
   166:       @Override String ja () {
   167:         return "Alt";
   168:       }
   169:     };
   170:     abstract int mask ();
   171:     abstract String paramK ();
   172:     abstract String en ();
   173:     abstract String ja ();
   174:   }  //enum Modifier
   175: 
   176:   static final Modifier[] MODIFIER_ARRAY = Modifier.values ();
   177:   static final int MODIFIERS = MODIFIER_ARRAY.length;
   178: 
   179: 
   180: 
   181:   public static enum Function {
   182:     FULLSCREEN {
   183:       @Override String en () {
   184:         return "Toggle full screen";
   185:       }
   186:       @Override String ja () {
   187:         return "全画面表示の切り替え";
   188:       }
   189:       @Override String paramV () {
   190:         return "fullscreen";
   191:       }
   192:       @Override boolean execute (boolean pressed) {
   193:         if (pressed) {
   194:           XEiJ.pnlToggleFullScreen ();
   195:         }
   196:         return true;
   197:       }
   198:     },
   199:     MAXIMIZED {
   200:       @Override String en () {
   201:         return "Toggle maximized";
   202:       }
   203:       @Override String ja () {
   204:         return "最大化の切り替え";
   205:       }
   206:       @Override String paramV () {
   207:         return "maximized";
   208:       }
   209:       @Override boolean execute (boolean pressed) {
   210:         if (pressed) {
   211:           XEiJ.pnlToggleMaximized ();
   212:         }
   213:         return true;
   214:       }
   215:     },
   216:     SEAMLESS {
   217:       @Override String en () {
   218:         return "Toggle seamless mouse";
   219:       }
   220:       @Override String ja () {
   221:         return "シームレスマウスの切り替え";
   222:       }
   223:       @Override String paramV () {
   224:         return "seamless";
   225:       }
   226:       @Override boolean execute (boolean pressed) {
   227:         if (pressed) {
   228:           Mouse.musSetSeamlessOn (!Mouse.musSeamlessOn);
   229:         }
   230:         return true;
   231:       }
   232:     },
   233:     SCREENSHOT {
   234:       @Override String en () {
   235:         return "Take a screenshot";
   236:       }
   237:       @Override String ja () {
   238:         return "スクリーンショットを撮る";
   239:       }
   240:       @Override String paramV () {
   241:         return "screenshot";
   242:       }
   243:       @Override boolean execute (boolean pressed) {
   244:         if (pressed) {
   245:           Keyboard.kbdDoCapture ();
   246:         }
   247:         return true;
   248:       }
   249:     },
   250:     TEXTCOPY {
   251:       @Override String en () {
   252:         return "Text screen copy";
   253:       }
   254:       @Override String ja () {
   255:         return "テキスト画面コピー";
   256:       }
   257:       @Override String paramV () {
   258:         return "textcopy";
   259:       }
   260:       @Override boolean execute (boolean pressed) {
   261:         if (pressed) {
   262:           TextCopy.txcCopy ();
   263:         }
   264:         return true;
   265:       }
   266:     },
   267:     GIFANIMATION {
   268:       @Override String en () {
   269:         return "Start recording GIF animation";
   270:       }
   271:       @Override String ja () {
   272:         return "GIF アニメーション録画開始";
   273:       }
   274:       @Override String paramV () {
   275:         return "gifanimation";
   276:       }
   277:       @Override boolean execute (boolean pressed) {
   278:         if (pressed) {
   279:           GIFAnimation.gifStartRecording ();
   280:         }
   281:         return true;
   282:       }
   283:     },
   284:     STOPANDSTART {
   285:       @Override String en () {
   286:         return "Stop and start";
   287:       }
   288:       @Override String ja () {
   289:         return "停止と再開";
   290:       }
   291:       @Override String paramV () {
   292:         return "stopandstart";
   293:       }
   294:       @Override boolean execute (boolean pressed) {
   295:         if (pressed) {
   296:           XEiJ.mpuStopAndStart ();
   297:         }
   298:         return true;
   299:       }
   300:     },
   301:     TRACE1 {
   302:       @Override String en () {
   303:         return "1 trace";
   304:       }
   305:       @Override String ja () {
   306:         return "トレース 1 回";
   307:       }
   308:       @Override String paramV () {
   309:         return "trace1";
   310:       }
   311:       @Override boolean execute (boolean pressed) {
   312:         if (pressed) {
   313:           XEiJ.mpuAdvance (1);
   314:         }
   315:         return true;
   316:       }
   317:     },
   318:     TRACE10 {
   319:       @Override String en () {
   320:         return "10 traces";
   321:       }
   322:       @Override String ja () {
   323:         return "トレース 10 回";
   324:       }
   325:       @Override String paramV () {
   326:         return "trace10";
   327:       }
   328:       @Override boolean execute (boolean pressed) {
   329:         if (pressed) {
   330:           XEiJ.mpuAdvance (10);
   331:         }
   332:         return true;
   333:       }
   334:     },
   335:     TRACE100 {
   336:       @Override String en () {
   337:         return "100 traces";
   338:       }
   339:       @Override String ja () {
   340:         return "トレース 100 回";
   341:       }
   342:       @Override String paramV () {
   343:         return "trace100";
   344:       }
   345:       @Override boolean execute (boolean pressed) {
   346:         if (pressed) {
   347:           XEiJ.mpuAdvance (100);
   348:         }
   349:         return true;
   350:       }
   351:     },
   352:     STEP1 {
   353:       @Override String en () {
   354:         return "1 step";
   355:       }
   356:       @Override String ja () {
   357:         return "ステップ 1 回";
   358:       }
   359:       @Override String paramV () {
   360:         return "step1";
   361:       }
   362:       @Override boolean execute (boolean pressed) {
   363:         if (pressed) {
   364:           XEiJ.mpuStep (1);
   365:         }
   366:         return true;
   367:       }
   368:     },
   369:     STEP10 {
   370:       @Override String en () {
   371:         return "10 steps";
   372:       }
   373:       @Override String ja () {
   374:         return "ステップ 10 回";
   375:       }
   376:       @Override String paramV () {
   377:         return "step10";
   378:       }
   379:       @Override boolean execute (boolean pressed) {
   380:         if (pressed) {
   381:           XEiJ.mpuStep (10);
   382:         }
   383:         return true;
   384:       }
   385:     },
   386:     STEP100 {
   387:       @Override String en () {
   388:         return "100 steps";
   389:       }
   390:       @Override String ja () {
   391:         return "ステップ 100 回";
   392:       }
   393:       @Override String paramV () {
   394:         return "step100";
   395:       }
   396:       @Override boolean execute (boolean pressed) {
   397:         if (pressed) {
   398:           XEiJ.mpuStep (100);
   399:         }
   400:         return true;
   401:       }
   402:     },
   403:     RETURN {
   404:       @Override String en () {
   405:         return "Step until return";
   406:       }
   407:       @Override String ja () {
   408:         return "ステップアンティルリターン";
   409:       }
   410:       @Override String paramV () {
   411:         return "return";
   412:       }
   413:       @Override boolean execute (boolean pressed) {
   414:         if (pressed) {
   415:           XEiJ.mpuStepUntilReturn ();
   416:         }
   417:         return true;
   418:       }
   419:     },
   420:     LEFTCLICK {
   421:       @Override String en () {
   422:         return "Left click";
   423:       }
   424:       @Override String ja () {
   425:         return "左クリック";
   426:       }
   427:       @Override String paramV () {
   428:         return "leftclick";
   429:       }
   430:       @Override boolean execute (boolean pressed) {
   431:         if (pressed) {
   432:           Mouse.musWheelButton = 1;  //左クリック
   433:           Mouse.musWheelReleaseTime = XEiJ.mpuClockTime + XEiJ.TMR_FREQ / 1000 * 100;  //下へ回転。左クリック100ms
   434:         }
   435:         return true;
   436:       }
   437:     },
   438:     RIGHTCLICK {
   439:       @Override String en () {
   440:         return "Right click";
   441:       }
   442:       @Override String ja () {
   443:         return "右クリック";
   444:       }
   445:       @Override String paramV () {
   446:         return "rightclick";
   447:       }
   448:       @Override boolean execute (boolean pressed) {
   449:         if (pressed) {
   450:           Mouse.musWheelButton = 2;  //右クリック
   451:           Mouse.musWheelReleaseTime = XEiJ.mpuClockTime + XEiJ.TMR_FREQ / 1000 * 100;  //上へ回転。右クリック100ms
   452:         }
   453:         return true;
   454:       }
   455:     },
   456:     DONOTHING {
   457:       @Override String en () {
   458:         return "No function";
   459:       }
   460:       @Override String ja () {
   461:         return "機能なし";
   462:       }
   463:       @Override String paramV () {
   464:         return "donothing";
   465:       }
   466:       @Override boolean execute (boolean pressed) {
   467:         return false;
   468:       }
   469:     };
   470:     abstract String en ();
   471:     abstract String ja ();
   472:     abstract String paramV ();
   473:     abstract boolean execute (boolean pressed);
   474:   }  //enum Function
   475: 
   476:   static final Function[] FUNCTION_ARRAY = Function.values ();
   477:   static final int FUNCTIONS = FUNCTION_ARRAY.length;
   478: 
   479: 
   480: 
   481:   //割り当て
   482:   //  assignment[MODIFIERS * bi + mi] = fi
   483:   final static int[] assignment = new int[MODIFIERS * BUTTONS];
   484: 
   485:   //ウインドウ
   486:   public static JFrame bfnFrame;
   487: 
   488:   //bfnInit ()
   489:   //  初期化
   490:   public static void bfnInit () {
   491:     //パラメータを復元する
   492:     for (int bi = 0; bi < BUTTONS; bi++) {
   493:       Button b = BUTTON_ARRAY[bi];
   494:       for (int mi = 0; mi < MODIFIERS; mi++) {
   495:         Modifier m = MODIFIER_ARRAY[mi];
   496:         String k = m.paramK () + b.paramK ();
   497:         String v = Settings.sgsGetString (k);
   498:         int fi = Function.DONOTHING.ordinal ();
   499:         for (int gi = 0; gi < FUNCTIONS; gi++) {
   500:           Function g = FUNCTION_ARRAY[gi];
   501:           if (g.paramV ().equals (v)) {
   502:             fi = gi;
   503:             break;
   504:           }
   505:         }
   506:         assignment[MODIFIERS * bi + mi] = fi;
   507:       }
   508:     }
   509:     switch (Settings.sgsGetString ("mousewheel")) {  //旧パラメータ。保存しない
   510:     case "trace":
   511:       //-wheelup=trace1
   512:       //-shiftwheelup=trace10
   513:       //-ctrlwheelup=trace100
   514:       //-wheeldown=step1
   515:       //-shiftwheeldown=step10
   516:       //-ctrlwheeldown=step100
   517:       //-altwheeldown=return
   518:       assignment[MODIFIERS * Button.WHEELUP.ordinal () + Modifier.ONLY.ordinal ()] = Function.TRACE1.ordinal ();
   519:       assignment[MODIFIERS * Button.WHEELUP.ordinal () + Modifier.SHIFT.ordinal ()] = Function.TRACE10.ordinal ();
   520:       assignment[MODIFIERS * Button.WHEELUP.ordinal () + Modifier.CTRL.ordinal ()] = Function.TRACE100.ordinal ();
   521:       assignment[MODIFIERS * Button.WHEELDOWN.ordinal () + Modifier.ONLY.ordinal ()] = Function.STEP1.ordinal ();
   522:       assignment[MODIFIERS * Button.WHEELDOWN.ordinal () + Modifier.SHIFT.ordinal ()] = Function.STEP10.ordinal ();
   523:       assignment[MODIFIERS * Button.WHEELDOWN.ordinal () + Modifier.CTRL.ordinal ()] = Function.STEP100.ordinal ();
   524:       assignment[MODIFIERS * Button.WHEELDOWN.ordinal () + Modifier.ALT.ordinal ()] = Function.RETURN.ordinal ();
   525:       break;
   526:     case "click":
   527:       //-wheelup=leftclick
   528:       //-wheeldown=rightclick
   529:       assignment[MODIFIERS * Button.WHEELUP.ordinal () + Modifier.ONLY.ordinal ()] = Function.LEFTCLICK.ordinal ();
   530:       assignment[MODIFIERS * Button.WHEELDOWN.ordinal () + Modifier.ONLY.ordinal ()] = Function.RIGHTCLICK.ordinal ();
   531:       break;
   532:     }
   533:   }  //bfnInit
   534: 
   535:   //bfnTini ()
   536:   //  後始末
   537:   public static void bfnTini () {
   538:     //パラメータを保存する
   539:     for (int bi = 0; bi < BUTTONS; bi++) {
   540:       Button b = BUTTON_ARRAY[bi];
   541:       for (int mi = 0; mi < MODIFIERS; mi++) {
   542:         Modifier m = MODIFIER_ARRAY[mi];
   543:         String k = m.paramK () + b.paramK ();
   544:         int fi = assignment[MODIFIERS * bi + mi];
   545:         Function f = FUNCTION_ARRAY[fi];
   546:         String v = f.paramV ();
   547:         Settings.sgsPutString (k, v);
   548:       }
   549:     }
   550:     Settings.sgsPutString ("mousewheel", "");  //旧パラメータ。保存しない
   551:   }  //bfnTini
   552: 
   553:   //bfnMakeMenuItem ()
   554:   public static JMenuItem bfnMakeMenuItem () {
   555:     return Multilingual.mlnText (
   556:       ComponentFactory.createMenuItem (
   557:         "F11/F12 and button function assignments",
   558:         new ActionListener () {
   559:           @Override public void actionPerformed (ActionEvent ae) {
   560:             bfnOpen ();
   561:           }
   562:         }),
   563:       "ja", "F11/F12 およびボタン機能割り当て");
   564:   }  //bfnMakeMenuItem
   565: 
   566:   //bfnStart ()
   567:   public static void bfnStart () {
   568:     if (RestorableFrame.rfmGetOpened (Settings.SGS_BFN_FRAME_KEY)) {
   569:       bfnOpen ();
   570:     }
   571:   }  //bfnStart
   572: 
   573:   //bfnOpen ()
   574:   //  ウィンドウを開く
   575:   public static void bfnOpen () {
   576:     if (bfnFrame == null) {
   577:       bfnMakeFrame ();
   578:     }
   579:     XEiJ.pnlExitFullScreen (false);
   580:     bfnFrame.setVisible (true);
   581:   }  //bfnOpen()
   582: 
   583:   //bfnMakeFrame ()
   584:   //  ウィンドウを作る
   585:   //  ここでは開かない
   586:   public static void bfnMakeFrame () {
   587:     ActionListener listener = new ActionListener () {
   588:       @Override public void actionPerformed (ActionEvent ae) {
   589:         int bmi = Integer.parseInt (ae.getActionCommand ());
   590:         int fi = bmi / (MODIFIERS * BUTTONS);
   591:         bmi -= MODIFIERS * BUTTONS * fi;
   592:         assignment[bmi] = fi;
   593:       }
   594:     };
   595:     //                                                                                                                     MODIFIERS*BUTTONS
   596:     //                     0       1     2        3      4                                                                               |
   597:     //              +-------------+--------------------------+---------+-------+-----------------+-------------------+----------+----------+
   598:     //            0 |             |         F11 key          | F12 key | Wheel | Wheel scroll up | Wheel scroll down | Button 4 | Button 5 |
   599:     //              |             +--+--------+-------+------+-+--+-+--+-+-+-+-+---+----+---+----+----+----+----+----+-+--+--+--+-+--+--+--+
   600:     //            1 |             |  | Shift+ | Ctrl+ | Alt+ | |  | |  | | | | |   |    |   |    |    |    |    |    | |  |  |  | |  |  |  |
   601:     //              +-------------+--+--------+-------+------+-+--+-+--+-+-+-+-+---+----+---+----+----+----+----+----+-+--+--+--+-+--+--+--+
   602:     //            2 | fullscreen  |X |   X    |   X   |  X   |X|X |X|X |X|X|X|X| X | X  | X | X  | X  | X  | X  | X  |X|X |X |X |X|X |X |X |
   603:     //              +-------------+--+--------+-------+------+-+--+-+--+-+-+-+-+---+----+---+----+----+----+----+----+-+--+--+--+-+--+--+--+
   604:     //            :
   605:     //              +-------------+--+--------+-------+------+-+--+-+--+-+-+-+-+---+----+---+----+----+----+----+----+-+--+--+--+-+--+--+--+
   606:     //  1+FUNCTIONS | no function |X |   X    |   X   |  X   |X|X |X|X |X|X|X|X| X | X  | X | X  | X  | X  | X  | X  |X|X |X |X |X|X |X |X |
   607:     //              +-------------+--+--------+-------+------+-+--+-+--+-+-+-+-+---+----+---+----+----+----+----+----+-+--+--+--+-+--+--+--+
   608:     //  ※水平線の位置はfi={0,6,14,16}の上に固定
   609:     //  各ボタンの左側に垂直線を加える
   610:     int colCount = 1 + (1 + MODIFIERS) * BUTTONS;
   611:     ArrayList<Object> cellList = new ArrayList<Object> ();
   612:     cellList.add ("");
   613:     for (int bi = 0; bi < BUTTONS; bi++) {
   614:       Button b = BUTTON_ARRAY[bi];
   615:       cellList.add (ComponentFactory.createVerticalSeparator ());
   616:       cellList.add (Multilingual.mlnText (ComponentFactory.createLabel (b.en ()), "ja", b.ja ()));
   617:     }
   618:     for (int bi = 0; bi < BUTTONS; bi++) {
   619:       for (int mi = 0; mi < MODIFIERS; mi++) {
   620:         Modifier m = MODIFIER_ARRAY[mi];
   621:         cellList.add (Multilingual.mlnText (ComponentFactory.createLabel (m.en ()), "ja", m.ja ()));
   622:       }
   623:     }
   624:     ButtonGroup[] group = new ButtonGroup[MODIFIERS * BUTTONS];
   625:     for (int fi = 0; fi < FUNCTIONS; fi++) {
   626:       Function f = FUNCTION_ARRAY[fi];
   627:       if (fi == 0 || fi == 6 || fi == 14 || fi == 16) {  //※
   628:         cellList.add (ComponentFactory.createHorizontalSeparator ());
   629:       }
   630:       cellList.add (Multilingual.mlnText (ComponentFactory.createLabel (f.en ()), "ja", f.ja ()));
   631:       for (int bi = 0; bi < BUTTONS; bi++) {
   632:         cellList.add (ComponentFactory.createVerticalSeparator ());
   633:         for (int mi = 0; mi < MODIFIERS; mi++) {
   634:           int bmi = MODIFIERS * bi + mi;
   635:           if (fi == 0) {
   636:             group[bmi] = new ButtonGroup ();
   637:           }
   638:           cellList.add (
   639:             ComponentFactory.setEnabled (
   640:               ComponentFactory.setText (
   641:                 ComponentFactory.createRadioButton (
   642:                   group[bmi],
   643:                   assignment[bmi] == fi,
   644:                   String.valueOf (MODIFIERS * BUTTONS * fi + bmi),  //commandをfbmiにする
   645:                   listener),
   646:                 ""),  //textを""にする
   647:               fi == Function.TEXTCOPY.ordinal () ? XEiJ.clpClipboard != null :  //テキスト画面コピーはクリップボードが必要
   648:               true)
   649:             );
   650:         }
   651:       }
   652:     }
   653:     String colStyles = "italic";
   654:     String cellStyles = "rowSpan=2";
   655:     for (int bi = 0; bi < BUTTONS; bi++) {
   656:       colStyles += ";lengthen";
   657:       for (int mi = 0; mi < MODIFIERS; mi++) {
   658:         colStyles += ";";
   659:       }
   660:       cellStyles += ";rowSpan=2;colSpan=" + MODIFIERS;
   661:     }
   662:     bfnFrame = Multilingual.mlnTitle (
   663:       ComponentFactory.createRestorableSubFrame (
   664:         Settings.SGS_BFN_FRAME_KEY,
   665:         "F11/F12 and button function assignments",
   666:         null,
   667:         ComponentFactory.setPreferredSize (
   668:           new JScrollPane (
   669:             ComponentFactory.setEmptyBorder (
   670:               ComponentFactory.createGridPanel (
   671:                 colCount,  //colCount
   672:                 2 + FUNCTIONS + 4,  //rowCount
   673:                 "paddingLeft=3,paddingRight=3,center",   //gridStyles
   674:                 colStyles,  //colStyles
   675:                 "italic;italic" +
   676:                 ";colSpan=" + colCount + ",widen" +  //0の上
   677:                 ";;;;;;;colSpan=" + colCount + ",widen" +  //6の上※
   678:                 ";;;;;;;;;colSpan=" + colCount + ",widen" +  //14の上※
   679:                 ";;;colSpan=" + colCount + ",widen",  //16の上※ rowStyles
   680:                 cellStyles,  //cellStyles
   681:                 cellList.toArray (new Object[0])),
   682:               6, 6, 6, 6)),
   683:           600, 380)),
   684:       "ja", "F11/F12 およびボタン機能割り当て");
   685:   }  //bfnMakeFrame()
   686: 
   687:   //consumed = bfnExecute (b, modifiersEx, pressed, forcedF)
   688:   //  ボタンが押されたまたは離された
   689:   public static boolean bfnExecute (Button b, int modifiersEx, boolean pressed, Function forcedF) {
   690:     int mask = modifiersEx & (InputEvent.SHIFT_DOWN_MASK | InputEvent.CTRL_DOWN_MASK | InputEvent.ALT_DOWN_MASK);
   691:     for (int mi = 0; mi < MODIFIERS; mi++) {
   692:       Modifier m = MODIFIER_ARRAY[mi];
   693:       if (m.mask () == mask) {
   694:         int bi = b.ordinal ();
   695:         int bmi = MODIFIERS * bi + mi;
   696:         int fi = assignment[bmi];
   697:         Function f = FUNCTION_ARRAY[fi];
   698:         if (forcedF != null) {
   699:           f = forcedF;
   700:         }
   701:         return f.execute (pressed);
   702:       }
   703:     }
   704:     return false;
   705:   }  //bfnExecute
   706: 
   707:   //bfnFullScreenText ()
   708:   //  全画面表示を解除するボタンを探して文字列で返す。なければnull
   709:   public static String bfnFullScreenText () {
   710:     int fi = Function.FULLSCREEN.ordinal ();  //全画面表示の切り替え
   711:     int gi = Function.MAXIMIZED.ordinal ();  //最大化の切り替え。全画面表示のとき全画面表示を解除する
   712:     for (int mi = 0; mi < MODIFIERS; mi++) {
   713:       for (int bi = 0; bi < BUTTONS; bi++) {
   714:         int a = assignment[MODIFIERS * bi + mi];
   715:         if (a == fi || a == gi) {
   716:           StringBuilder sb = new StringBuilder ();
   717:           if (mi != 0) {
   718:             sb.append (MODIFIER_ARRAY[mi].en ()).append ("+");
   719:           }
   720:           if (Multilingual.mlnJapanese) {
   721:             sb.append (BUTTON_ARRAY[bi].ja ());
   722:           } else {
   723:             sb.append (BUTTON_ARRAY[bi].en ());
   724:           }
   725:           return sb.toString ();
   726:         }
   727:       }
   728:     }
   729:     return null;
   730:   }  //bfnFullScreenText
   731: 
   732: 
   733: 
   734: }  //class ButtonFunction