1 / 1
快捷键: ← → 切换
R 旋转 F 翻转 0 重置

Java代码

xfherun
2025-11-27 20:16:09 124 阅读 · 技术科技 · Java工程师
原创 
  1. package com.xfherun.midiforge.gui;

  2. 

  3. import com.xfherun.languages.Language;

  4. import com.xfherun.midiforge.animations.LoadAnimation;

  5. import com.xfherun.midiforge.exits.Exit;

  6. import com.xfherun.midiforge.gui.dialogs.MIDIForgeTickLoopDialog;

  7. import com.xfherun.midiforge.gui.renderer.MIDIRendererPanel;

  8. import com.xfherun.midiforge.gui.ui.componentuis.MIDIForgeMenuBarUI;

  9. import com.xfherun.midiforge.gui.ui.componentuis.MIDIForgeMenuUI;

  10. import com.xfherun.midiforge.languages.SystemLanguage;

  11. import com.xfherun.midiforge.logger.Logger;

  12. import com.xfherun.midiforge.main.References;

  13. import com.xfherun.midiforge.utils.GraphicsUtilities;

  14. import com.xfherun.midiforge.utils.MathUtilities;

  15. import com.xfherun.midiforge.utils.ThreadUtilities;

  16. import com.xfherun.midiplayer.DefaultMidiRenderer;

  17. import com.xfherun.midiplayer.LoopOption;

  18. import com.xfherun.midiplayer.MidiSequence;

  19. import com.xfherun.midiplayer.PianoKeyboardRenderer;

  20. 

  21. import javax.sound.midi.MidiSystem;

  22. import javax.sound.midi.MidiUnavailableException;

  23. import javax.sound.midi.Receiver;

  24. import javax.swing.*;

  25. import javax.swing.filechooser.FileNameExtensionFilter;

  26. import java.awt.*;

  27. import java.awt.datatransfer.DataFlavor;

  28. import java.awt.datatransfer.Transferable;

  29. import java.awt.datatransfer.UnsupportedFlavorException;

  30. import java.awt.event.*;

  31. import java.io.File;

  32. import java.io.IOException;

  33. import java.util.ArrayList;

  34. import java.util.LinkedHashSet;

  35. import java.util.List;

  36. 

  37. /**

  38.  * 主窗口

  39.  * project: MidiForge

  40.  *

  41.  * @author xfherun 何润

  42.  */

  43. public class MainWindow extends JFrame

  44. {

  45.     /**

  46.      * 窗口是否显示

  47.      */

  48.     protected volatile boolean rendering = false;

  49. 

  50.     /**

  51.      * 默认的空参构造 -> class: MainWindow

  52.      *

  53.      * @author xfherun 何润

  54.      */

  55.     public MainWindow()

  56.     {

  57.         initialization();

  58.     }

  59. 

  60.     /**

  61.      * 关闭窗口

  62.      *

  63.      * @author xfherun 何润

  64.      */

  65.     public final void close()

  66.     {

  67.         implClose();

  68.     }

  69. 

  70.     /**

  71.      * 实现关闭

  72.      *

  73.      * @author xfherun 何润

  74.      */

  75.     protected void implClose()

  76.     {

  77.         Logger.LOGGER.info("Window closing...");

  78.         setVisible(false);

  79.         dispose();

  80.         Exit.exit(true);

  81.     }

  82. 

  83.     /**

  84.      * 初始化

  85.      *

  86.      * @author xfherun 何润

  87.      */

  88.     protected void initialization()

  89.     {

  90.         Logger.LOGGER.info("The window starts initializing...");

  91.         setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);

  92.         addWindowListener(new WindowAdapter()

  93.         {

  94.             @Override

  95.             public void windowClosing(WindowEvent e)

  96.             {

  97.                 close();

  98.             }

  99.         });

  100.         setTitle(SystemLanguage.translate("application.window.title"));

  101.         try

  102.         {

  103.             Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();

  104.             setSize(

  105.                     MathUtilities.round(screenSize.getWidth() * 0.667),

  106.                     MathUtilities.round(screenSize.getHeight() * 0.667)

  107.             );

  108.         }

  109.         catch (Throwable e)

  110.         {

  111.             Logger.LOGGER.error("Unable to set window size!", e);

  112.             setSize(850, 480);

  113.         }

  114.         setLocationRelativeTo(null);

  115.         Logger.LOGGER.info("The window size is set to: " + getWidth() + " * " + getHeight());

  116.         Logger.LOGGER.info("window position is set to: " + getX() + " * " + getY());

  117.         Logger.LOGGER.info("Start initializing the window component...");

  118.         initializationComponents();

  119.         Logger.LOGGER.info("The window component is initialized!");

  120.         Logger.LOGGER.info("The window is initialized!");

  121.     }

  122. 

  123.     @Override

  124.     public void paint(Graphics g)

  125.     {

  126.         if (!rendering)

  127.             rendering = true;

  128.         super.paint(g);

  129.     }

  130. 

  131.     /**

  132.      * 获取 rendering 的值

  133.      *

  134.      * @return rendering 的值

  135.      * @author xfherun 何润

  136.      */

  137.     public boolean isRendering()

  138.     {

  139.         return rendering;

  140.     }

  141. 

  142.     /**

  143.      * MIDI渲染器面板

  144.      */

  145.     protected volatile MIDIRendererPanel midiRendererPanel;

  146. 

  147.     /**

  148.      * 顶部栏

  149.      */

  150.     protected volatile JPanel topBar;

  151. 

  152.     /**

  153.      * 卡片面板

  154.      */

  155.     private volatile JPanel cardPanel;

  156. 

  157.     /**

  158.      * 创建播放菜单

  159.      *

  160.      * @return 返回集合

  161.      * @author xfherun 何润

  162.      */

  163.     protected ArrayList<JComponent> createPlayMenus()

  164.     {

  165.         ArrayList<JComponent> arrayList = new ArrayList<>();

  166.         JMenuItem playAndPause = new JMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.play.playAndPause.text"));

  167.         JMenuItem stop = new JMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.play.stop.text"));

  168.         JMenuItem fwd = new JMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.play.tickForward.text"));

  169.         JMenuItem back = new JMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.play.tickBackward.text"));

  170.         JCheckBoxMenuItem enableLoop = new JCheckBoxMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.play.enableLoop.text"));

  171.         JMenuItem volumeForward = new JMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.play.volumeForward.text"));

  172.         JMenuItem volumeBackward = new JMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.play.volumeBackward.text"));

  173.         JCheckBoxMenuItem muted = new JCheckBoxMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.play.mute.text"));

  174.         {

  175.             playAndPause.setAccelerator(KeyStroke.getKeyStroke("SPACE"));

  176.             stop.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_E, InputEvent.CTRL_MASK));

  177.             fwd.setAccelerator(KeyStroke.getKeyStroke("RIGHT"));

  178.             back.setAccelerator(KeyStroke.getKeyStroke("LEFT"));

  179.             enableLoop.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_L, InputEvent.CTRL_MASK));

  180.             volumeForward.setAccelerator(KeyStroke.getKeyStroke("UP"));

  181.             volumeBackward.setAccelerator(KeyStroke.getKeyStroke("DOWN"));

  182.             muted.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_M, InputEvent.CTRL_MASK));

  183.         }

  184.         DefaultMidiRenderer renderer = midiRendererPanel.getRenderer();

  185.         if (renderer == null)

  186.         {

  187.             playAndPause.setEnabled(false);

  188.             stop.setEnabled(false);

  189.             fwd.setEnabled(false);

  190.             back.setEnabled(false);

  191.             enableLoop.setEnabled(false);

  192.             volumeForward.setEnabled(false);

  193.             volumeBackward.setEnabled(false);

  194.             muted.setEnabled(false);

  195.         }

  196. 

  197.         if (renderer != null)

  198.         {

  199.             playAndPause.addActionListener(e ->

  200.             {

  201.                 if (renderer.isRunning()) renderer.stop();

  202.                 else renderer.start();

  203.             });

  204. 

  205.             stop.addActionListener(e ->

  206.             {

  207.                 renderer.stop();

  208.                 renderer.setTickPosition(0L);

  209.             });

  210. 

  211.             long finalTickStep = 1000000000L;

  212.             fwd.addActionListener(e ->

  213.                     renderer.setTimePosition(renderer.getTimePosition() + finalTickStep));

  214. 

  215.             back.addActionListener(e ->

  216.                     renderer.setTimePosition(renderer.getTimePosition() - finalTickStep));

  217. 

  218.             muted.setSelected(renderer.isMuted());

  219.             muted.addActionListener(e ->

  220.                     renderer.setMuted(muted.isSelected()));

  221. 

  222.             volumeForward.addActionListener(e ->

  223.             {

  224.                 JSlider volumeSlider = midiRendererPanel.getVolumeSlider();

  225.                 volumeSlider.setValue(volumeSlider.getValue() + 10);

  226.             });

  227.             volumeBackward.addActionListener(e ->

  228.             {

  229.                 JSlider volumeSlider = midiRendererPanel.getVolumeSlider();

  230.                 volumeSlider.setValue(volumeSlider.getValue() - 10);

  231.             });

  232. 

  233.             enableLoop.setSelected(midiRendererPanel.isLoop());

  234.             enableLoop.addActionListener(e ->

  235.             {

  236.                 if (!enableLoop.isSelected()) midiRendererPanel.setLoop(false, 0L, -1L, 0);

  237.                 else

  238.                 {

  239.                     MIDIForgeTickLoopDialog midiForgeTickLoopDialog = new MIDIForgeTickLoopDialog(MainWindow.this, renderer);

  240.                     midiForgeTickLoopDialog.setVisible(true);

  241.                     int loopCount = midiForgeTickLoopDialog.getLoopCount();

  242.                     LoopOption loopOption = midiForgeTickLoopDialog.getLoopOption();

  243.                     long startPointLong = midiForgeTickLoopDialog.getStartPointLong();

  244.                     long endPointLong = midiForgeTickLoopDialog.getEndPointLong();

  245.                     if (loopOption != null)

  246.                     {

  247.                         if (LoopOption.NO_LOOP.equals(loopOption)) return;

  248.                         if (LoopOption.INDEFINITELY_LOOP.equals(loopOption)) loopCount = -1;

  249.                         midiRendererPanel.setLoop(true, startPointLong, endPointLong, loopCount);

  250.                     }

  251.                 }

  252.             });

  253.         }

  254. 

  255.         arrayList.add(playAndPause);

  256.         arrayList.add(stop);

  257.         arrayList.add(fwd);

  258.         arrayList.add(back);

  259.         arrayList.add(new JPopupMenu.Separator());

  260.         arrayList.add(enableLoop);

  261.         arrayList.add(new JPopupMenu.Separator());

  262.         arrayList.add(volumeForward);

  263.         arrayList.add(volumeBackward);

  264.         arrayList.add(muted);

  265.         return arrayList;

  266.     }

  267. 

  268.     /**

  269.      * 选择MIDI文件

  270.      *

  271.      * @param multipleChoices 是否多选

  272.      * @return 返回文件数组

  273.      * @author xfherun 何润

  274.      */

  275.     protected File[] selectedMIDIFile(boolean multipleChoices)

  276.     {

  277.         JFileChooser jFileChooser = new JFileChooser();

  278.         jFileChooser.setDialogType(JFileChooser.OPEN_DIALOG);

  279.         jFileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);

  280.         jFileChooser.setMultiSelectionEnabled(multipleChoices);

  281.         jFileChooser.setDialogTitle(SystemLanguage.translate("application.utilities.midiFileChooser.window.title"));

  282.         jFileChooser.setFileFilter(new FileNameExtensionFilter(

  283.                 SystemLanguage.translate("application.utilities.typeMIDI.description.text"),

  284.                 "mid", "midi"

  285.         ));

  286.         jFileChooser.setSelectedFile(new File("").getAbsoluteFile());

  287.         int option = jFileChooser.showOpenDialog(MainWindow.this);

  288.         if (option == JFileChooser.APPROVE_OPTION)

  289.         {

  290.             if (jFileChooser.isMultiSelectionEnabled())

  291.                 return jFileChooser.getSelectedFiles();

  292.             return new File[]{jFileChooser.getSelectedFile()};

  293.         }

  294.         return null;

  295.     }

  296. 

  297.     /**

  298.      * 当前MIDI文件

  299.      */

  300.     protected volatile File currentMIDIFile;

  301. 

  302.     /**

  303.      * 使用MIDI接收器

  304.      */

  305.     private static final boolean useMidiReceiver = true;

  306. 

  307.     /**

  308.      * 获取MIDI接收器

  309.      *

  310.      * @return 返回MIDI接收器

  311.      * @author xfherun 何润

  312.      */

  313.     protected Receiver getMIDIReceiver()

  314.     {

  315.         if (!useMidiReceiver) return null;

  316.         try

  317.         {

  318.             return MidiSystem.getReceiver();

  319.         }

  320.         catch (Throwable e)

  321.         {

  322.             Logger.LOGGER.error("Unable to get a MIDI receiver!", e);

  323.         }

  324.         return null;

  325.     }

  326. 

  327.     /**

  328.      * 创建文件菜单

  329.      *

  330.      * @return 返回集合

  331.      * @author xfherun 何润

  332.      */

  333.     protected ArrayList<JComponent> createFileMenus()

  334.     {

  335.         ArrayList<JComponent> arrayList = new ArrayList<>();

  336.         JMenuItem openSong = new JMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.file.openSong.text"));

  337.         JMenuItem reopenSong = new JMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.file.reopenSong.text", (currentMIDIFile != null ? currentMIDIFile.getName() : SystemLanguage.translate("application.window.home.menubar.menu.file.reopenSong.sub.text"))));

  338.         JMenuItem closeFile = new JMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.file.closeFile.text"));

  339.         JMenu library = new JMenu(SystemLanguage.translate("application.window.home.menubar.menu.file.library.text"));

  340.         {

  341.             JMenuItem addFile = new JMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.file.library.addFile.text"));

  342.             JMenuItem addDirectory = new JMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.file.library.addDirectory.text"));

  343.             addFile.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F, InputEvent.CTRL_MASK));

  344.             addDirectory.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_D, InputEvent.CTRL_MASK));

  345.             library.add(addFile);

  346.             library.add(addDirectory);

  347.         }

  348.         openSong.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, InputEvent.CTRL_MASK));

  349.         reopenSong.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_R, InputEvent.CTRL_MASK));

  350.         closeFile.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_W, InputEvent.CTRL_MASK));

  351.         library.setMnemonic('L');

  352. 

  353.         if (currentMIDIFile == null || !currentMIDIFile.exists() || !currentMIDIFile.isFile())

  354.             reopenSong.setEnabled(false);

  355. 

  356.         openSong.addActionListener(e ->

  357.         {

  358.             File[] files = selectedMIDIFile(false);

  359.             if (files != null)

  360.             {

  361.                 File midiFile = files[0];

  362.                 if (midiFile.getName().toLowerCase().endsWith(".mid") || midiFile.getName().toLowerCase().endsWith(".midi"))

  363.                 {

  364.                     ThreadUtilities.asynchronous(that ->

  365.                     {

  366.                         Logger.LOGGER.info("Selected MIDI File: " + midiFile.getAbsolutePath());

  367.                         loadSong(midiFile, getMIDIReceiver());

  368.                     });

  369.                 }

  370.             }

  371.         });

  372.         closeFile.addActionListener(e ->

  373.         {

  374.             if (currentMIDIFile == null) return;

  375.             Logger.LOGGER.info("Start closing MIDI files... currentMIDIFile -> " + currentMIDIFile.getAbsolutePath());

  376.             closeSong();

  377.         });

  378.         reopenSong.addActionListener(e ->

  379.         {

  380.             if (currentMIDIFile == null) return;

  381.             File reopenMIDIFile = currentMIDIFile;

  382.             if (reopenMIDIFile.exists() && reopenMIDIFile.isFile() && (reopenMIDIFile.getName().toLowerCase().endsWith(".mid") || reopenMIDIFile.getName().toLowerCase().endsWith(".midi")))

  383.             {

  384.                 Logger.LOGGER.info("Start reopening this MIDI song: " + reopenMIDIFile.getAbsolutePath());

  385.                 ThreadUtilities.asynchronous(that ->

  386.                 {

  387.                     closeSong();

  388.                     loadSong(reopenMIDIFile, getMIDIReceiver());

  389.                 });

  390.             }

  391.             else

  392.             {

  393.                 Logger.LOGGER.warn("Invalid MIDI files: " + reopenMIDIFile.getAbsolutePath());

  394.                 currentMIDIFile = null;

  395.             }

  396.         });

  397.         arrayList.add(openSong);

  398.         arrayList.add(reopenSong);

  399.         arrayList.add(closeFile);

  400.         arrayList.add(new JPopupMenu.Separator());

  401.         arrayList.add(library);

  402.         return arrayList;

  403.     }

  404. 

  405.     /**

  406.      * 创建视图菜单

  407.      *

  408.      * @return 返回集合

  409.      * @author xfherun 何润

  410.      */

  411.     protected ArrayList<JComponent> createViewMenus()

  412.     {

  413.         DefaultMidiRenderer renderer = midiRendererPanel.getRenderer();

  414.         ArrayList<JComponent> arrayList = new ArrayList<>();

  415.         JCheckBoxMenuItem playbackToolbar = new JCheckBoxMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.view.playbackToolbar.text"));

  416.         JCheckBoxMenuItem libraryPanel = new JCheckBoxMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.view.libraryPanel.text"));

  417.         JCheckBoxMenuItem pianoKeyboard = new JCheckBoxMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.view.pianoKeyboard.text"));

  418.         JCheckBoxMenuItem noteLabels = new JCheckBoxMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.view.noteLabels.text"));

  419.         JMenu changedPianoKeyboardOrientation = new JMenu(SystemLanguage.translate("application.window.home.menubar.menu.view.changedPianoKeyboardOrientation.text"));

  420.         JCheckBoxMenuItem alwaysOnTop = new JCheckBoxMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.view.alwaysOnTop.text"));

  421.         JCheckBoxMenuItem fullScreen = new JCheckBoxMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.view.fullScreen.text"));

  422.         playbackToolbar.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_T, InputEvent.CTRL_MASK));

  423.         libraryPanel.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Y, InputEvent.CTRL_MASK));

  424.         pianoKeyboard.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_K, InputEvent.CTRL_MASK));

  425.         noteLabels.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, InputEvent.CTRL_MASK));

  426.         changedPianoKeyboardOrientation.setMnemonic('C');

  427. 

  428.         playbackToolbar.setSelected(midiRendererPanel.getTopBarPanel().isVisible());

  429.         playbackToolbar.addActionListener(e ->

  430.         {

  431.             midiRendererPanel.getTopBarPanel().setVisible(playbackToolbar.isSelected());

  432.             midiRendererPanel.updateSize();

  433.             GraphicsUtilities.updateComponents(midiRendererPanel, MainWindow.this);

  434.         });

  435. 

  436.         fullScreen.setSelected(isUndecorated());

  437.         fullScreen.addActionListener(e ->

  438.         {

  439.             if (fullScreen.isSelected())

  440.                 midiRendererPanel.fullScreenOn();

  441.             else midiRendererPanel.fullScreenOff();

  442.         });

  443. 

  444.         JMenuItem h = new JMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.view.changedPianoKeyboardOrientation.H.text"));

  445.         JMenuItem v = new JMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.view.changedPianoKeyboardOrientation.V.text"));

  446.         h.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_H, InputEvent.CTRL_MASK));

  447.         v.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_V, InputEvent.CTRL_MASK));

  448.         h.setEnabled(false);

  449.         v.setEnabled(false);

  450.         pianoKeyboard.setEnabled(false);

  451.         noteLabels.setEnabled(false);

  452.         if (renderer != null)

  453.         {

  454.             h.setEnabled(true);

  455.             v.setEnabled(true);

  456.             pianoKeyboard.setEnabled(true);

  457.             noteLabels.setEnabled(true);

  458.             h.addActionListener(e ->

  459.             {

  460.                 renderer.getPianoKeyboardRenderer().setOrientation(PianoKeyboardRenderer.HORIZONTAL);

  461.                 midiRendererPanel.updateSize();

  462.             });

  463. 

  464.             v.addActionListener(e ->

  465.             {

  466.                 renderer.getPianoKeyboardRenderer().setOrientation(PianoKeyboardRenderer.VERTICAL);

  467.                 midiRendererPanel.updateSize();

  468.             });

  469. 

  470.             pianoKeyboard.addActionListener(e ->

  471.             {

  472. 

  473.             });

  474. 

  475.             noteLabels.addActionListener(e ->

  476.             {

  477. 

  478.             });

  479.         }

  480.         changedPianoKeyboardOrientation.add(h);

  481.         changedPianoKeyboardOrientation.add(v);

  482.         alwaysOnTop.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_A, InputEvent.CTRL_MASK));

  483.         fullScreen.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, InputEvent.ALT_MASK));

  484.         {

  485.             alwaysOnTop.setSelected(isAlwaysOnTop());

  486.         }

  487.         {

  488.             alwaysOnTop.addActionListener(e -> setAlwaysOnTop(alwaysOnTop.isSelected()));

  489.         }

  490.         arrayList.add(playbackToolbar);

  491.         arrayList.add(libraryPanel);

  492.         arrayList.add(pianoKeyboard);

  493.         arrayList.add(noteLabels);

  494.         arrayList.add(changedPianoKeyboardOrientation);

  495.         arrayList.add(new JPopupMenu.Separator());

  496.         arrayList.add(alwaysOnTop);

  497.         arrayList.add(fullScreen);

  498.         return arrayList;

  499.     }

  500. 

  501.     /**

  502.      * 创建选项菜单

  503.      *

  504.      * @return 返回集合

  505.      * @author xfherun 何润

  506.      */

  507.     protected ArrayList<JComponent> createOptionsMenus()

  508.     {

  509.         ArrayList<JComponent> arrayList = new ArrayList<>();

  510.         JMenuItem preferences = new JMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.options.preferences.text"));

  511.         preferences.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_P, InputEvent.CTRL_MASK));

  512.         arrayList.add(preferences);

  513.         return arrayList;

  514.     }

  515. 

  516.     /**

  517.      * 创建帮助菜单

  518.      *

  519.      * @return 返回集合

  520.      * @author xfherun 何润

  521.      */

  522.     protected ArrayList<JComponent> createHelpMenus()

  523.     {

  524.         ArrayList<JComponent> arrayList = new ArrayList<>();

  525.         JMenuItem online = new JMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.help.online.text"));

  526.         JMenuItem about = new JMenuItem(SystemLanguage.translate("application.window.home.menubar.menu.help.about.text"));

  527.         online.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_I, InputEvent.CTRL_MASK));

  528.         about.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_U, InputEvent.CTRL_MASK));

  529.         arrayList.add(online);

  530.         arrayList.add(about);

  531.         return arrayList;

  532.     }

  533. 

  534.     /**

  535.      * 初始化窗口组件

  536.      *

  537.      * @author xfherun 何润

  538.      */

  539.     protected void initializationComponents()

  540.     {

  541.         cardPanel = new JPanel();

  542.         cardPanel.setOpaque(true);

  543.         cardPanel.setLayout(new CardLayout());

  544.         {

  545.             topBar = new JPanel();

  546.             topBar.setOpaque(true);

  547.             topBar.setBackground(Color.BLACK);

  548.             topBar.setLayout(new BorderLayout());

  549.             topBar.setMinimumSize(new Dimension(0, 50));

  550.             topBar.setMaximumSize(new Dimension(Integer.MAX_VALUE, 50));

  551.             topBar.setPreferredSize(new Dimension(0, 50));

  552.             JLabel logoTextLabel = new JLabel();

  553.             logoTextLabel.setForeground(new Color(217, 217, 217, 255));

  554.             logoTextLabel.setBorder(BorderFactory.createEmptyBorder(0, 50, 0, 50));

  555.             logoTextLabel.setFont(new Font(logoTextLabel.getFont().getFamily(), Font.BOLD, MathUtilities.round(topBar.getPreferredSize().getHeight() * 0.61)));

  556.             logoTextLabel.setText(References.APPLICATION_NAME);

  557.             topBar.add(logoTextLabel, BorderLayout.WEST);

  558.             JMenuBar menuBar = new JMenuBar();

  559.             JMenu file = createMenu(SystemLanguage.translate("application.window.home.menubar.menu.file.text"));

  560.             JMenu play = createMenu(SystemLanguage.translate("application.window.home.menubar.menu.play.text"));

  561.             JMenu view = createMenu(SystemLanguage.translate("application.window.home.menubar.menu.view.text"));

  562.             JMenu options = createMenu(SystemLanguage.translate("application.window.home.menubar.menu.options.text"));

  563.             JMenu help = createMenu(SystemLanguage.translate("application.window.home.menubar.menu.help.text"));

  564.             file.setMnemonic('F');

  565.             play.setMnemonic('P');

  566.             view.setMnemonic('V');

  567.             options.setMnemonic('O');

  568.             help.setMnemonic('H');

  569.             file.addItemListener(e ->

  570.             {

  571.                 Logger.LOGGER.info("Start Creation Menu: File");

  572.                 JMenu source = (JMenu) e.getSource();

  573.                 source.removeAll();

  574.                 for (JComponent menu : createFileMenus())

  575.                     source.add(menu);

  576.                 GraphicsUtilities.updateComponents(source);

  577.             });

  578.             play.addItemListener(e ->

  579.             {

  580.                 Logger.LOGGER.info("Start Creation Menu: Play");

  581.                 JMenu source = (JMenu) e.getSource();

  582.                 source.removeAll();

  583.                 for (JComponent menu : createPlayMenus())

  584.                     source.add(menu);

  585.                 GraphicsUtilities.updateComponents(source);

  586.             });

  587.             view.addItemListener(e ->

  588.             {

  589.                 Logger.LOGGER.info("Start Creation Menu: View");

  590.                 JMenu source = (JMenu) e.getSource();

  591.                 source.removeAll();

  592.                 for (JComponent menu : createViewMenus())

  593.                     source.add(menu);

  594.                 GraphicsUtilities.updateComponents(source);

  595.             });

  596.             options.addItemListener(e ->

  597.             {

  598.                 Logger.LOGGER.info("Start Creation Menu: Options");

  599.                 JMenu source = (JMenu) e.getSource();

  600.                 source.removeAll();

  601.                 for (JComponent menu : createOptionsMenus())

  602.                     source.add(menu);

  603.                 GraphicsUtilities.updateComponents(source);

  604.             });

  605.             help.addItemListener(e ->

  606.             {

  607.                 Logger.LOGGER.info("Start Creation Menu: Help");

  608.                 JMenu source = (JMenu) e.getSource();

  609.                 source.removeAll();

  610.                 for (JComponent menu : createHelpMenus())

  611.                     source.add(menu);

  612.                 GraphicsUtilities.updateComponents(source);

  613.             });

  614.             menuBar.add(file);

  615.             menuBar.add(play);

  616.             menuBar.add(view);

  617.             menuBar.add(options);

  618.             menuBar.add(help);

  619.             menuBar.setBorder(BorderFactory.createEmptyBorder(9, 9, 9, 50));

  620.             topBar.add(menuBar, BorderLayout.EAST);

  621.             getContentPane().add(topBar, BorderLayout.NORTH);

  622.         }

  623. 

  624. 

  625.         {

  626.             midiRendererPanel = new MIDIRendererPanel();

  627.             midiRendererPanel.addMouseListener(new MouseAdapter()

  628.             {

  629.                 @Override

  630.                 public void mouseClicked(MouseEvent e)

  631.                 {

  632.                     if (e.getButton() == 3)

  633.                     {

  634.                         ArrayList<JComponent> alls = new ArrayList<>();

  635.                         {

  636.                             {

  637.                                 JMenu file0 = new JMenu(SystemLanguage.translate("application.window.home.menubar.menu.file.text"));

  638.                                 file0.setMnemonic('F');

  639.                                 ArrayList<JComponent> fileMenus = createFileMenus();

  640.                                 for (JComponent fileMenu : fileMenus) file0.add(fileMenu);

  641.                                 alls.add(file0);

  642.                             }

  643.                             {

  644.                                 JMenu view0 = new JMenu(SystemLanguage.translate("application.window.home.menubar.menu.view.text"));

  645.                                 view0.setMnemonic('V');

  646.                                 ArrayList<JComponent> fileMenus = createViewMenus();

  647.                                 for (JComponent fileMenu : fileMenus) view0.add(fileMenu);

  648.                                 alls.add(view0);

  649.                             }

  650.                             {

  651.                                 alls.addAll(createOptionsMenus());

  652.                             }

  653.                         }

  654.                         alls.add(new JPopupMenu.Separator());

  655.                         alls.addAll(createPlayMenus());

  656.                         JPopupMenu popupMenu = new JPopupMenu();

  657.                         for (JComponent playMenu : alls)

  658.                             popupMenu.add(playMenu);

  659.                         popupMenu.show(midiRendererPanel, e.getX() + 1, e.getY() + 1);

  660.                     }

  661.                 }

  662.             });

  663.             JPanel panel = new JPanel();

  664.             panel.setLayout(new BorderLayout());

  665.             midiRendererPanel.setTransferHandler(new TransferHandler()

  666.             {

  667.                 @Override

  668.                 public boolean canImport(TransferSupport support)

  669.                 {

  670.                     return true;

  671.                 }

  672. 

  673.                 @Override

  674.                 public boolean importData(TransferSupport support)

  675.                 {

  676.                     LinkedHashSet<File> files = new LinkedHashSet<>();

  677.                     Transferable transferable = support.getTransferable();

  678.                     if (transferable != null && support.isDataFlavorSupported(DataFlavor.javaFileListFlavor))

  679.                     {

  680.                         DataFlavor[] dataFlavors = support.getDataFlavors();

  681.                         if (dataFlavors != null && dataFlavors.length > 0)

  682.                         {

  683.                             for (DataFlavor dataFlavor : dataFlavors)

  684.                             {

  685.                                 try

  686.                                 {

  687.                                     if (dataFlavor == null) continue;

  688.                                     Object transferData = transferable.getTransferData(dataFlavor);

  689.                                     if (transferData instanceof List<?> list)

  690.                                     {

  691.                                         for (Object o : list)

  692.                                         {

  693.                                             if (o instanceof File file)

  694.                                             {

  695.                                                 String name = file.getName().toLowerCase();

  696.                                                 if (name.endsWith(".mid") || name.endsWith(".midi"))

  697.                                                     files.add(file);

  698.                                             }

  699.                                         }

  700.                                     }

  701.                                 }

  702.                                 catch (Throwable ignored)

  703.                                 {

  704.                                 }

  705.                             }

  706.                         }

  707.                     }

  708.                     if (files.size() != 1) return false;

  709.                     for (File file : files)

  710.                     {

  711.                         ThreadUtilities.asynchronous(that ->

  712.                         {

  713.                             Logger.LOGGER.info("Selected MIDI File: " + file.getAbsolutePath());

  714.                             loadSong(file, getMIDIReceiver());

  715.                         });

  716.                         break;

  717.                     }

  718.                     return true;

  719.                 }

  720.             });

  721.             panel.add(midiRendererPanel, BorderLayout.CENTER);

  722.             cardPanel.add("Renderer", panel);

  723.         }

  724.         getContentPane().add(cardPanel, BorderLayout.CENTER);

  725.     }

  726. 

  727.     /**

  728.      * 创建菜单

  729.      *

  730.      * @param text 文本

  731.      * @return 返回菜单对象

  732.      * @author xfherun 何润

  733.      */

  734.     protected JMenu createMenu(String text)

  735.     {

  736.         return new JMenu(text)

  737.         {

  738.             @Override

  739.             public void updateUI()

  740.             {

  741.                 setUI(new MIDIForgeMenuUI()

  742.                 {

  743.                     @Override

  744.                     public void installUI(JComponent c)

  745.                     {

  746.                         super.installUI(c);

  747.                         c.setOpaque(true);

  748.                         c.setBackground(new Color(0, 0, 0, 255));

  749.                         c.setForeground(new Color(204, 204, 204, 255));

  750.                         selectionBackground = new Color(0, 0, 0, 255);

  751.                         selectionForeground = new Color(255, 255, 255, 255);

  752.                         int margin = 4;

  753.                         int p = 2;

  754.                         c.setBorder(BorderFactory.createEmptyBorder(margin, margin * p, margin, margin * p));

  755.                     }

  756.                 });

  757.             }

  758.         };

  759.     }

  760. 

  761.     /**

  762.      * 关闭歌曲

  763.      *

  764.      * @author xfherun 何润

  765.      */

  766.     public void closeSong()

  767.     {

  768.         DefaultMidiRenderer renderer = midiRendererPanel.getRenderer();

  769.         if (renderer != null)

  770.             renderer.close();

  771.         midiRendererPanel.setRenderer(null);

  772.         midiRendererPanel.getDraggedProgressBar().setPercentage(0.0);

  773.         midiRendererPanel.getDraggedProgressBar().setDraggable(false);

  774.         setTitle(SystemLanguage.translate("application.window.title"));

  775.         GraphicsUtilities.updateComponents(this);

  776.     }

  777. 

  778.     /**

  779.      * 加载歌曲

  780.      *

  781.      * @param file     文件

  782.      * @param receiver MIDI接收器

  783.      * @author xfherun 何润

  784.      */

  785.     public void loadSong(File file, Receiver receiver)

  786.     {

  787.         closeSong();

  788.         MidiSequence sequence;

  789.         LoadAnimation.LoadAnimationDialog loadAnimationDialog = new LoadAnimation.LoadAnimationDialog(MainWindow.this);

  790.         try

  791.         {

  792.             sequence = MidiSequence.loadMidiSequence(currentMIDIFile = file, null);

  793.         }

  794.         catch (Throwable e)

  795.         {

  796.             try

  797.             {

  798.                 loadAnimationDialog.setVisible(false);

  799.                 loadAnimationDialog.dispose();

  800.                 loadAnimationDialog = null;

  801.             }

  802.             catch (Throwable ex)

  803.             {

  804.                 e.addSuppressed(ex);

  805.             }

  806.             Logger.LOGGER.error("Loading MIDI sequence error!", e);

  807.             return;

  808.         }

  809.         midiRendererPanel.setRenderer(new DefaultMidiRenderer());

  810.         DefaultMidiRenderer renderer = midiRendererPanel.getRenderer();

  811.         renderer.open(sequence, receiver);

  812.         try

  813.         {

  814.             loadAnimationDialog.setVisible(false);

  815.             loadAnimationDialog.dispose();

  816.             loadAnimationDialog = null;

  817.         }

  818.         catch (Throwable e)

  819.         {

  820.             Logger.LOGGER.warn("Closing the loading animation window failed!", e);

  821.         }

  822.         midiRendererPanel.getDraggedProgressBar().setPercentage(0.0);

  823.         midiRendererPanel.getDraggedProgressBar().setDraggable(true);

  824.         midiRendererPanel.updateMetronome();

  825.         midiRendererPanel.updateVolume();

  826.         setTitle("*" + SystemLanguage.translate("application.window.title") + " - " + currentMIDIFile.getAbsolutePath());

  827.         GraphicsUtilities.updateComponents(this);

  828.     }

  829. 

  830.     /**

  831.      * 获取 midiRendererPanel 的值

  832.      *

  833.      * @return midiRendererPanel 的值

  834.      * @author xfherun 何润

  835.      */

  836.     public MIDIRendererPanel getMidiRendererPanel()

  837.     {

  838.         return midiRendererPanel;

  839.     }

  840. }
返回顶部

    • 提示