/[svn]/jsampler/trunk/src/org/jsampler/view/fantasia/Channel.java
ViewVC logotype

Annotation of /jsampler/trunk/src/org/jsampler/view/fantasia/Channel.java

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1734 - (hide annotations) (download)
Sun May 4 18:40:13 2008 UTC (15 years, 11 months ago) by iliev
File size: 26243 byte(s) 
* bugfix: JSampler took forever to load a configuration with
  too many sampler channels
* Implemented option to show different channel view when
  the mouse pointer is over sampler channel
  (choose Edit/Preferences, then click the `Defaults' tab)
1 iliev 912 /*
2     * JSampler - a java front-end for LinuxSampler
3     *
4 iliev 1688 * Copyright (C) 2005-2008 Grigor Iliev <grigor@grigoriliev.com>
5 iliev 912 *
6     * This file is part of JSampler.
7     *
8     * JSampler is free software; you can redistribute it and/or modify
9     * it under the terms of the GNU General Public License version 2
10     * as published by the Free Software Foundation.
11     *
12     * JSampler is distributed in the hope that it will be useful,
13     * but WITHOUT ANY WARRANTY; without even the implied warranty of
14     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15     * GNU General Public License for more details.
16     *
17     * You should have received a copy of the GNU General Public License
18     * along with JSampler; if not, write to the Free Software
19     * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
20     * MA 02111-1307 USA
21     */
22    
23     package org.jsampler.view.fantasia;
24    
25 iliev 1467 import java.awt.Container;
26 iliev 1732 import java.awt.Dimension;
27 iliev 1467 import java.awt.Rectangle;
28 iliev 912
29     import java.awt.event.ActionEvent;
30     import java.awt.event.ActionListener;
31 iliev 1732 import java.awt.event.MouseAdapter;
32     import java.awt.event.MouseEvent;
33 iliev 912
34 iliev 1285 import java.beans.PropertyChangeEvent;
35     import java.beans.PropertyChangeListener;
36    
37 iliev 1732 import java.text.NumberFormat;
38    
39     import javax.swing.AbstractAction;
40     import javax.swing.Action;
41 iliev 912 import javax.swing.BoxLayout;
42 iliev 1732 import javax.swing.ButtonGroup;
43 iliev 912 import javax.swing.DefaultListCellRenderer;
44 iliev 1732 import javax.swing.ImageIcon;
45 iliev 912 import javax.swing.JButton;
46 iliev 1540 import javax.swing.JComponent;
47 iliev 1732 import javax.swing.JLabel;
48     import javax.swing.JMenuItem;
49 iliev 912 import javax.swing.JPanel;
50 iliev 1732 import javax.swing.JPopupMenu;
51     import javax.swing.JRadioButtonMenuItem;
52 iliev 1467 import javax.swing.JScrollPane;
53 iliev 912 import javax.swing.JToggleButton;
54 iliev 1732 import javax.swing.JToolBar;
55 iliev 912
56 iliev 1732 import net.sf.juife.InformationDialog;
57 iliev 912 import net.sf.juife.TitleBar;
58    
59 iliev 1285 import org.jdesktop.swingx.JXCollapsiblePane;
60    
61 iliev 912 import org.jsampler.CC;
62 iliev 1540 import org.jsampler.HF;
63 iliev 912 import org.jsampler.SamplerChannelModel;
64    
65     import org.jsampler.event.SamplerChannelEvent;
66 iliev 1285 import org.jsampler.event.SamplerChannelListEvent;
67     import org.jsampler.event.SamplerChannelListListener;
68 iliev 912 import org.jsampler.event.SamplerChannelListener;
69    
70 iliev 1734 import org.jsampler.view.JSChannel;
71    
72 iliev 1732 import org.jsampler.view.std.JSChannelOutputRoutingDlg;
73     import org.jsampler.view.std.JSFxSendsPane;
74     import org.jsampler.view.std.JSInstrumentChooser;
75     import org.jsampler.view.std.JSVolumeEditorPopup;
76    
77     import org.linuxsampler.lscp.SamplerChannel;
78    
79     import static org.jsampler.view.fantasia.FantasiaI18n.i18n;
80 iliev 1285 import static org.jsampler.view.fantasia.FantasiaPrefs.*;
81 iliev 1732 import static org.jsampler.view.fantasia.FantasiaUtils.*;
82     import static org.jsampler.view.std.JSVolumeEditorPopup.VolumeType;
83 iliev 912
84    
85     /**
86     *
87     * @author Grigor Iliev
88     */
89 iliev 1734 public class Channel extends JSChannel {
90 iliev 1285 private final JXCollapsiblePane mainPane;
91 iliev 1730 private ChannelOptionsView channelOptionsView;
92     private final ChannelOptionsPane optionsPane = new ChannelOptionsPane();
93 iliev 912
94 iliev 1734 private final ViewTracker viewTracker;
95    
96 iliev 1732 private InformationDialog fxSendsDlg = null;
97    
98     private final ContextMenu contextMenu = new ContextMenu();
99    
100 iliev 1730 private boolean selected = false;
101 iliev 912
102 iliev 1730 private AnimatedPorpetyListener animatedPorpetyListener = new AnimatedPorpetyListener();
103 iliev 912
104 iliev 1730 class AnimatedPorpetyListener implements PropertyChangeListener {
105     public void
106     propertyChange(PropertyChangeEvent e) {
107     mainPane.setAnimated(preferences().getBoolProperty(ANIMATED));
108     }
109     }
110 iliev 912
111     /**
112     * Creates a new instance of <code>Channel</code> using the specified
113     * non-<code>null</code> channel model.
114     * @param model The model to be used by this channel.
115     * @throws IllegalArgumentException If the model is <code>null</code>.
116     */
117     public
118     Channel(SamplerChannelModel model) {
119 iliev 1318 this(model, null);
120     }
121    
122     /**
123     * Creates a new instance of <code>Channel</code> using the specified
124     * non-<code>null</code> channel model.
125     * @param model The model to be used by this channel.
126     * @param listener A listener which is notified when the newly created
127     * channel is fully expanded on the screen.
128     * @throws IllegalArgumentException If the model is <code>null</code>.
129     */
130     public
131     Channel(SamplerChannelModel model, final ActionListener listener) {
132 iliev 912 super(model);
133    
134     setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
135     optionsPane.setAlignmentX(JPanel.CENTER_ALIGNMENT);
136    
137 iliev 1285 mainPane = new JXCollapsiblePane();
138 iliev 1734 viewTracker = new ViewTracker();
139    
140 iliev 1285 mainPane.getContentPane().setLayout (
141     new BoxLayout(mainPane.getContentPane(), BoxLayout.Y_AXIS)
142     );
143 iliev 912
144 iliev 1732 int viewIdx = preferences().getIntProperty(DEFAULT_CHANNEL_VIEW);
145     if(viewIdx == 0) {
146     contextMenu.rbmiSmallView.doClick(0);
147     } else if(viewIdx == 1) {
148     contextMenu.rbmiNormalView.doClick(0);
149     } else {
150     contextMenu.rbmiNormalView.doClick(0);
151     }
152 iliev 1730
153 iliev 1285 setOpaque(false);
154    
155 iliev 912 getModel().addSamplerChannelListener(getHandler());
156    
157     updateChannelInfo();
158 iliev 1285
159     add(mainPane);
160    
161 iliev 1318 if(listener != null) {
162     final String s = JXCollapsiblePane.ANIMATION_STATE_KEY;
163     mainPane.addPropertyChangeListener(s, new PropertyChangeListener() {
164     public void
165     propertyChange(PropertyChangeEvent e) {
166     if(e.getNewValue() == "expanded") {
167 iliev 1467 // TODO: this should be done regardles the listener != null?
168 iliev 1318 mainPane.removePropertyChangeListener(s, this);
169 iliev 1467 ///////
170 iliev 1318 listener.actionPerformed(null);
171 iliev 1467 ensureChannelIsVisible();
172     } else if(e.getNewValue() == "expanding/collapsing") {
173     ensureChannelIsVisible();
174 iliev 1318 }
175     }
176     });
177     }
178    
179 iliev 1285 mainPane.setAnimated(false);
180     mainPane.setCollapsed(true);
181     mainPane.setAnimated(preferences().getBoolProperty(ANIMATED));
182     mainPane.setCollapsed(false);
183    
184 iliev 1730 preferences().addPropertyChangeListener(ANIMATED, animatedPorpetyListener);
185 iliev 1318
186     if(listener != null) {
187     javax.swing.SwingUtilities.invokeLater(new Runnable() {
188     public void
189     run() { listener.actionPerformed(null); }
190     });
191     }
192 iliev 1341
193     CC.getSamplerModel().addSamplerChannelListListener(getHandler());
194 iliev 912 }
195    
196 iliev 1467 private void
197     ensureChannelIsVisible() {
198     Container p = getParent();
199     JScrollPane sp = null;
200     while(p != null) {
201     if(p instanceof JScrollPane) {
202     sp = (JScrollPane)p;
203     break;
204     }
205     p = p.getParent();
206     }
207     if(sp == null) return;
208     int h = sp.getViewport().getView().getHeight();
209     sp.getViewport().scrollRectToVisible(new Rectangle(0, h - 2, 1, 1));
210     }
211    
212 iliev 912 /**
213     * Determines whether the channel is selected.
214     * @return <code>true</code> if the channel is selected, <code>false</code> otherwise.
215     */
216     public boolean isSelected() { return selected; }
217    
218     /**
219     * Sets the selection state of this channel.
220     * This method is invoked when the selection state of the channel has changed.
221     * @param select Specifies the new selection state of this channel;
222     * <code>true</code> to select the channel, <code>false</code> otherwise.
223     */
224     public void
225     setSelected(boolean select) {
226    
227     selected = select;
228     }
229    
230     /** Shows the channel properties. */
231     public void
232 iliev 1285 expandChannel() { expandChannel(optionsPane.isAnimated()); }
233 iliev 912
234 iliev 1285 /** Shows the channel properties. */
235     public void
236     expandChannel(boolean animated) {
237     boolean b = optionsPane.isAnimated();
238     optionsPane.setAnimated(animated);
239 iliev 1734 viewTracker.getCurrentView().expandChannel();
240 iliev 1285 optionsPane.setAnimated(b);
241     }
242 iliev 912
243     /**
244     * Updates the channel settings. This method is invoked when changes to the
245     * channel were made.
246     */
247     private void
248     updateChannelInfo() {
249 iliev 1734 viewTracker.getCurrentView().updateChannelInfo();
250     viewTracker.getCurrentView().getChannelOptionsView().updateChannelInfo();
251 iliev 912 }
252    
253 iliev 1732 public void
254     loadInstrument() {
255     JSInstrumentChooser dlg = FantasiaUtils.createInstrumentChooser(CC.getMainFrame());
256     dlg.setVisible(true);
257    
258     if(!dlg.isCancelled()) {
259     SamplerChannelModel m = getModel();
260     m.loadBackendInstrument(dlg.getInstrumentFile(), dlg.getInstrumentIndex());
261     }
262     }
263    
264 iliev 1734 public void
265     fallbackToOriginalView() {
266     viewTracker.fallbackToOriginalView();
267     }
268    
269     public boolean
270     isUsingOriginalView() {
271     return viewTracker.isUsingOriginalView();
272     }
273    
274 iliev 1341 protected void
275     onDestroy() {
276     CC.getSamplerModel().removeSamplerChannelListListener(getHandler());
277 iliev 1730 preferences().removePropertyChangeListener(ANIMATED, animatedPorpetyListener);
278 iliev 1341
279 iliev 1734 viewTracker.onDestroy();
280 iliev 1341 }
281 iliev 1730
282     public void
283     remove() {
284     if(!mainPane.isAnimated()) {
285     CC.getSamplerModel().removeBackendChannel(getChannelId());
286     return;
287     }
288    
289     String s = JXCollapsiblePane.ANIMATION_STATE_KEY;
290     mainPane.addPropertyChangeListener(s, getHandler());
291     mainPane.setCollapsed(true);
292     }
293 iliev 1341
294 iliev 1730 public void
295     showOptionsPane(boolean show) { optionsPane.showOptionsPane(show); }
296    
297 iliev 1732 public void
298     showFxSendsDialog() {
299     if(fxSendsDlg != null && fxSendsDlg.isVisible()) {
300     fxSendsDlg.toFront();
301     return;
302     }
303     FxSendsPane p = new FxSendsPane(getModel());
304     int id = getModel().getChannelId();
305     fxSendsDlg = new InformationDialog(CC.getMainFrame(), p);
306     fxSendsDlg.setTitle(i18n.getLabel("FxSendsDlg.title", id));
307     fxSendsDlg.setModal(false);
308     fxSendsDlg.showCloseButton(false);
309     fxSendsDlg.setVisible(true);
310     }
311    
312 iliev 912 private final EventHandler eventHandler = new EventHandler();
313    
314     private EventHandler
315     getHandler() { return eventHandler; }
316    
317 iliev 1730 private class EventHandler implements SamplerChannelListener,
318     SamplerChannelListListener, PropertyChangeListener {
319 iliev 912 /**
320     * Invoked when changes are made to a sampler channel.
321     * @param e A <code>SamplerChannelEvent</code> instance
322     * containing event information.
323     */
324     public void
325     channelChanged(SamplerChannelEvent e) { updateChannelInfo(); }
326    
327     /**
328     * Invoked when the number of active disk streams has changed.
329     * @param e A <code>SamplerChannelEvent</code> instance
330     * containing event information.
331     */
332     public void
333     streamCountChanged(SamplerChannelEvent e) {
334 iliev 1734 viewTracker.getCurrentView().updateStreamCount(getModel().getStreamCount());
335 iliev 912 }
336    
337     /**
338     * Invoked when the number of active voices has changed.
339     * @param e A <code>SamplerChannelEvent</code> instance
340     * containing event information.
341     */
342     public void
343     voiceCountChanged(SamplerChannelEvent e) {
344 iliev 1734 viewTracker.getCurrentView().updateVoiceCount(getModel().getVoiceCount());
345 iliev 912 }
346 iliev 1341
347     /**
348     * Invoked when a new sampler channel is created.
349     * @param e A <code>SamplerChannelListEvent</code>
350     * instance providing the event information.
351     */
352     public void
353     channelAdded(SamplerChannelListEvent e) { }
354    
355     /**
356     * Invoked when a sampler channel is removed.
357     * @param e A <code>SamplerChannelListEvent</code>
358     * instance providing the event information.
359     */
360     public void
361     channelRemoved(SamplerChannelListEvent e) {
362     // Some cleanup when the channel is removed.
363     if(e.getChannelModel().getChannelId() == getChannelId()) {
364     onDestroy();
365     }
366     }
367 iliev 1285
368 iliev 912 public void
369 iliev 1285 propertyChange(PropertyChangeEvent e) {
370     if(e.getNewValue() == "collapsed") {
371     CC.getSamplerModel().removeBackendChannel(getChannelId());
372     }
373     }
374 iliev 912 }
375 iliev 1732
376 iliev 1734 private static boolean viewTrackerMousePressed = false;
377    
378     class ViewTracker extends MouseAdapter implements PropertyChangeListener {
379     private ChannelView originalView;
380     private ChannelView mouseOverView;
381     private ChannelView currentView;
382    
383    
384     private boolean mouseOver = false;
385    
386     private final ActionListener guiListener;
387    
388     ViewTracker() {
389     guiListener = new ActionListener() {
390     public void
391     actionPerformed(ActionEvent e) {
392     if(viewTrackerMousePressed) return;
393    
394     if(mainPane.getMousePosition(true) != null) {
395     mouseEntered(null);
396     } else {
397     mouseExited(null);
398     }
399     }
400     };
401    
402     updateMouseOverViewType();
403    
404     String s = DIFFERENT_CHANNEL_VIEW_ON_MOUSE_OVER;
405     preferences().addPropertyChangeListener(s, this);
406    
407     s = CHANNEL_VIEW_ON_MOUSE_OVER;
408     preferences().addPropertyChangeListener(s, this);
409     }
410    
411     public boolean
412     isUsingOriginalView() {
413     return currentView == originalView;
414     }
415    
416     private void
417     installListeners() {
418     ((MainFrame)CC.getMainFrame()).getGuiTimer().addActionListener(guiListener);
419     }
420    
421     private void
422     uninstallListeners() {
423     ((MainFrame)CC.getMainFrame()).getGuiTimer().removeActionListener(guiListener);
424     }
425    
426     private void
427     updateMouseOverViewType() {
428     if(mouseOverView != null) {
429     mouseOverView.removeEnhancedMouseListener(this);
430     }
431    
432     boolean b;
433     b = preferences().getBoolProperty(DIFFERENT_CHANNEL_VIEW_ON_MOUSE_OVER);
434     if(!b) {
435     mouseOverView = null;
436     uninstallListeners();
437     return;
438     }
439    
440     Channel channel = Channel.this;
441     int i = preferences().getIntProperty(CHANNEL_VIEW_ON_MOUSE_OVER);
442    
443     switch(i) {
444     case 0: mouseOverView = new SmallChannelView(channel); break;
445     case 1: mouseOverView = new NormalChannelView(channel); break;
446     default:mouseOverView = null;
447     }
448    
449     if(mouseOverView != null) {
450     installListeners();
451     mouseOverView.addEnhancedMouseListener(this);
452     }
453     }
454    
455     public ChannelView
456     getCurrentView() { return currentView; }
457    
458     public void
459     setView(ChannelView view) {
460     setView(view, true);
461     }
462    
463     public void
464     setView(ChannelView view, boolean manual) {
465     boolean selected = false;
466     if(currentView != null) selected = currentView.isOptionsButtonSelected();
467    
468     if(manual) {
469     if(originalView != null) {
470     originalView.removeEnhancedMouseListener(this);
471     }
472    
473     if(originalView != currentView) destroyOriginalView();
474     if(currentView != null && currentView.getType() == view.getType()) {
475     originalView = currentView;
476     originalView.addEnhancedMouseListener(this);
477     destroyView(view);
478     return;
479     }
480    
481     removeCurrentView();
482    
483     originalView = view;
484     originalView.addEnhancedMouseListener(this);
485     currentView = view;
486     } else {
487     if(view.getType() == getCurrentView().getType()) {
488     destroyView(view);
489     return;
490     }
491    
492     removeCurrentView();
493     currentView = view;
494     }
495    
496     currentView.setOptionsButtonSelected(selected);
497    
498     updateView();
499     }
500    
501     private void
502     updateView() {
503     JComponent c = getCurrentView().getChannelOptionsView().getComponent();
504     optionsPane.setContentPane(c);
505    
506     updateChannelInfo();
507    
508     mainPane.add(getCurrentView().getComponent());
509     mainPane.add(optionsPane);
510     mainPane.validate();
511     mainPane.revalidate();
512     mainPane.repaint();
513     }
514    
515     public void
516     fallbackToOriginalView() {
517     if(currentView == originalView) return;
518    
519     boolean selected = false;
520     if(currentView != null) selected = currentView.isOptionsButtonSelected();
521    
522     removeCurrentView();
523     currentView = originalView;
524     currentView.setOptionsButtonSelected(selected);
525    
526     updateView();
527     }
528    
529     private void
530     removeCurrentView() { removeView(currentView); }
531    
532     private void
533     destroyCurrentView() { destroyView(currentView); }
534    
535     private void
536     removeOriginalView() { removeView(originalView); }
537    
538     private void
539     destroyOriginalView() { destroyView(originalView); }
540    
541     private void
542     removeView(ChannelView view) {
543     if(view == null) return;
544    
545     mainPane.remove(view.getComponent());
546     mainPane.remove(optionsPane);
547    
548     destroyView(view);
549     }
550    
551     private void
552     destroyView(ChannelView view) {
553     if(view == null) return;
554    
555     view.uninstallView();
556     view.getChannelOptionsView().uninstallView();
557    
558     view = null;
559     }
560    
561     private void
562     mouseEntered() {
563     if(mouseOverView == null) return;
564     if(getCurrentView().getType() == mouseOverView.getType()) return;
565    
566     JSChannel[] channels = CC.getMainFrame().getChannelsPane(0).getChannels();
567     for(JSChannel c : channels) {
568     if(c == Channel.this) continue;
569    
570     Channel chn = (Channel)c;
571     if(!(chn).isUsingOriginalView()) chn.fallbackToOriginalView();
572     }
573    
574     setView(mouseOverView, false);
575     }
576    
577     private void
578     mouseExited() {
579     if(mouseOverView == null) return;
580     if(getCurrentView().getType() == originalView.getType()) return;
581    
582     fallbackToOriginalView();
583     }
584    
585     public void
586     mouseEntered(MouseEvent e) {
587     if(viewTrackerMousePressed) return;
588    
589     if(mouseOver) return;
590     mouseOver = true;
591     mouseEntered();
592     }
593    
594     public void
595     mouseExited(MouseEvent e) {
596     if(viewTrackerMousePressed) return;
597    
598     if(mainPane.getMousePosition(true) != null) return;
599     if(!mouseOver) return;
600     mouseOver = false;
601     mouseExited();
602     }
603    
604     public void
605     mousePressed(MouseEvent e) {
606     viewTrackerMousePressed = true;
607     }
608    
609     public void
610     mouseReleased(MouseEvent e) {
611     viewTrackerMousePressed = false;
612     }
613    
614     public void
615     onDestroy() {
616     destroyCurrentView();
617     destroyOriginalView();
618    
619     uninstallListeners();
620    
621     if(currentView != null) {
622     currentView.removeEnhancedMouseListener(this);
623     }
624    
625     if(mouseOverView != null) {
626     mouseOverView.removeEnhancedMouseListener(this);
627     }
628    
629     String s = DIFFERENT_CHANNEL_VIEW_ON_MOUSE_OVER;
630     preferences().removePropertyChangeListener(s, this);
631    
632     s = CHANNEL_VIEW_ON_MOUSE_OVER;
633     preferences().removePropertyChangeListener(s, this);
634     }
635    
636     public void
637     propertyChange(PropertyChangeEvent e) {
638     updateMouseOverViewType();
639     }
640     }
641    
642 iliev 1732 class EditInstrumentAction extends AbstractAction implements SamplerChannelListener {
643     EditInstrumentAction() {
644     super(i18n.getMenuLabel("channels.editInstrument"));
645     channelChanged(null);
646     getModel().addSamplerChannelListener(this);
647     }
648    
649     public void
650     actionPerformed(ActionEvent e) {
651     CC.getSamplerModel().editBackendInstrument(getChannelId());
652     }
653    
654     public void
655     channelChanged(SamplerChannelEvent e) {
656     boolean b = getChannelInfo().getInstrumentStatus() == 100;
657     setEnabled(b);
658     }
659    
660     public void
661     streamCountChanged(SamplerChannelEvent e) { }
662    
663     public void
664     voiceCountChanged(SamplerChannelEvent e) { }
665     }
666    
667     class FxSendsAction extends AbstractAction {
668     FxSendsAction() {
669     super(i18n.getMenuLabel("channels.fxSends"));
670     }
671    
672     public void
673     actionPerformed(ActionEvent e) {
674     showFxSendsDialog();
675     }
676     }
677    
678     class ChannelRoutingAction extends AbstractAction implements SamplerChannelListener {
679     ChannelRoutingAction() {
680     super(i18n.getMenuLabel("channels.channelRouting"));
681     channelChanged(null);
682     getModel().addSamplerChannelListener(this);
683     }
684    
685     public void
686     actionPerformed(ActionEvent e) {
687     SamplerChannel c = getChannelInfo();
688     new JSChannelOutputRoutingDlg(CC.getMainFrame(), c).setVisible(true);
689     }
690    
691     public void
692     channelChanged(SamplerChannelEvent e) {
693     boolean b = getChannelInfo().getAudioOutputDevice() != -1;
694     setEnabled(b);
695     }
696    
697     public void
698     streamCountChanged(SamplerChannelEvent e) { }
699    
700     public void
701     voiceCountChanged(SamplerChannelEvent e) { }
702     }
703    
704     class SetSmallViewAction extends AbstractAction {
705     SetSmallViewAction() {
706     super(i18n.getMenuLabel("channels.smallView"));
707     }
708    
709     public void
710     actionPerformed(ActionEvent e) {
711 iliev 1734 viewTracker.setView(new SmallChannelView(Channel.this));
712 iliev 1732 }
713     }
714    
715     class SetNormalViewAction extends AbstractAction {
716     SetNormalViewAction() {
717     super(i18n.getMenuLabel("channels.normalView"));
718     }
719    
720     public void
721     actionPerformed(ActionEvent e) {
722 iliev 1734 viewTracker.setView(new NormalChannelView(Channel.this));
723 iliev 1732 }
724     }
725    
726     public ContextMenu
727     getContextMenu() { return contextMenu; }
728    
729     class ContextMenu extends MouseAdapter {
730     private final JPopupMenu menu = new JPopupMenu();
731    
732     protected final JRadioButtonMenuItem rbmiSmallView;
733     protected final JRadioButtonMenuItem rbmiNormalView;
734    
735     ContextMenu() {
736     menu.add(new JMenuItem(new EditInstrumentAction()));
737     menu.addSeparator();
738    
739     rbmiSmallView = new JRadioButtonMenuItem(new SetSmallViewAction());
740     rbmiNormalView = new JRadioButtonMenuItem(new SetNormalViewAction());
741    
742     ButtonGroup group = new ButtonGroup();
743     group.add(rbmiSmallView);
744     group.add(rbmiNormalView);
745    
746     menu.add(rbmiSmallView);
747     menu.add(rbmiNormalView);
748    
749     menu.addSeparator();
750     menu.add(new JMenuItem(new FxSendsAction()));
751     menu.add(new JMenuItem(new ChannelRoutingAction()));
752     }
753    
754     public void
755     mousePressed(MouseEvent e) {
756     if(e.isPopupTrigger()) show(e);
757     }
758    
759     public void
760     mouseReleased(MouseEvent e) {
761     if(e.isPopupTrigger()) show(e);
762     }
763    
764     void
765     show(MouseEvent e) {
766     menu.show(e.getComponent(), e.getX(), e.getY());
767     }
768     }
769    
770     class FxSendsPane extends JSFxSendsPane {
771     FxSendsPane(SamplerChannelModel model) {
772     super(model);
773    
774     actionAddFxSend.putValue(Action.SMALL_ICON, Res.iconNew16);
775     actionRemoveFxSend.putValue(Action.SMALL_ICON, Res.iconDelete16);
776     }
777    
778     protected JToolBar
779     createToolBar() {
780     JToolBar tb = new JToolBar();
781     Dimension d = new Dimension(Short.MAX_VALUE, tb.getPreferredSize().height);
782     tb.setMaximumSize(d);
783     tb.setFloatable(false);
784     tb.setAlignmentX(JPanel.RIGHT_ALIGNMENT);
785    
786     tb.add(new ToolbarButton(actionAddFxSend));
787     tb.add(new ToolbarButton(actionRemoveFxSend));
788    
789     return tb;
790     }
791     }
792    
793     public static class StreamVoiceCountPane extends JPanel {
794     private final Channel channel;
795    
796     private final JLabel lStreams = createScreenLabel(" --");
797     private final JLabel lSlash = createScreenLabel("/");
798     private final JLabel lVoices = createScreenLabel("-- ");
799    
800     public
801     StreamVoiceCountPane(Channel channel) {
802     this.channel = channel;
803    
804     setOpaque(false);
805     setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
806     lStreams.setFont(Res.fontScreenMono);
807     lStreams.setHorizontalAlignment(JLabel.RIGHT);
808     lStreams.setToolTipText(i18n.getLabel("Channel.streamVoiceCount"));
809    
810     Dimension d = lStreams.getPreferredSize();
811     lStreams.setMinimumSize(d);
812     lStreams.setPreferredSize(d);
813     lStreams.setMaximumSize(d);
814     add(lStreams);
815    
816     lSlash.setFont(Res.fontScreenMono);
817     lSlash.setToolTipText(i18n.getLabel("Channel.streamVoiceCount"));
818     add(lSlash);
819    
820     lVoices.setFont(Res.fontScreenMono);
821     lVoices.setToolTipText(i18n.getLabel("Channel.streamVoiceCount"));
822    
823     d = lStreams.getPreferredSize();
824     lVoices.setMinimumSize(d);
825     lVoices.setPreferredSize(d);
826     lVoices.setMaximumSize(d);
827     add(lVoices);
828    
829     lStreams.addMouseListener(channel.getContextMenu());
830     lSlash.addMouseListener(channel.getContextMenu());
831     lVoices.addMouseListener(channel.getContextMenu());
832     }
833    
834     public void
835     updateStreamCount(int count) {
836     lStreams.setText(count == 0 ? " --" : String.valueOf(count));
837     }
838    
839     public void
840     updateVoiceCount(int count) {
841     lVoices.setText(count == 0 ? "-- " : String.valueOf(count));
842     }
843     }
844    
845     public static class VolumePane extends JPanel {
846     private final Channel channel;
847     private final JButton btnVolume = createScreenButton("");
848     private JSVolumeEditorPopup popupVolume;
849    
850     private static NumberFormat numberFormat = NumberFormat.getInstance();
851     static { numberFormat.setMaximumFractionDigits(1); }
852    
853     public
854     VolumePane(final Channel channel) {
855     this.channel = channel;
856     setOpaque(false);
857     setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
858    
859     btnVolume.setIcon(Res.iconVolume14);
860     btnVolume.setIconTextGap(2);
861     btnVolume.setAlignmentX(RIGHT_ALIGNMENT);
862     btnVolume.setHorizontalAlignment(btnVolume.LEFT);
863     updateVolumeInfo(100);
864     Dimension d = btnVolume.getPreferredSize();
865     d.width = 57;
866     btnVolume.setPreferredSize(d);
867     btnVolume.setMinimumSize(d);
868    
869     add(btnVolume);
870    
871     btnVolume.addActionListener(new ActionListener() {
872     public void
873     actionPerformed(ActionEvent e) {
874     if(popupVolume.isVisible()) {
875     popupVolume.commit();
876     popupVolume.hide();
877     } else {
878     float vol = channel.getModel().getChannelInfo().getVolume();
879     popupVolume.setCurrentVolume(vol);
880     popupVolume.show();
881     }
882     }
883     });
884    
885     popupVolume = new JSVolumeEditorPopup(btnVolume, VolumeType.CHANNEL);
886    
887     popupVolume.addActionListener(new ActionListener() {
888     public void
889     actionPerformed(ActionEvent e) {
890     channel.getModel().setBackendVolume(popupVolume.getVolumeFactor());
891     }
892     });
893    
894     btnVolume.addMouseListener(channel.getContextMenu());
895     }
896    
897     public void
898     updateVolumeInfo(int volume) {
899     if(CC.getViewConfig().isMeasurementUnitDecibel()) {
900     String s = numberFormat.format(HF.percentsToDecibels(volume));
901     btnVolume.setText(s + "dB");
902     } else {
903     btnVolume.setText(String.valueOf(volume) + "%");
904     }
905     }
906     }
907    
908     public static class PowerButton extends PixmapToggleButton implements ActionListener {
909     private final Channel channel;
910    
911     PowerButton(Channel channel) {
912     this(channel, Res.gfxPowerOff, Res.gfxPowerOn);
913     }
914    
915     PowerButton(Channel channel, ImageIcon defaultIcon, ImageIcon selectedIcon) {
916     super(defaultIcon, selectedIcon);
917    
918     this.channel = channel;
919    
920     setSelected(true);
921     addActionListener(this);
922     setToolTipText(i18n.getButtonLabel("Channel.ttRemoveChannel"));
923     }
924    
925     public void
926     actionPerformed(ActionEvent e) {
927     boolean b = preferences().getBoolProperty(CONFIRM_CHANNEL_REMOVAL);
928     if(b) {
929     String s = i18n.getMessage("Channel.remove?", channel.getChannelId());
930     if(!HF.showYesNoDialog(channel, s)) {
931     setSelected(true);
932     return;
933     }
934     }
935     channel.remove();
936     }
937    
938     public boolean
939     contains(int x, int y) { return (x - 11)*(x - 11) + (y - 11)*(y - 11) < 71; }
940     }
941    
942     public static class OptionsButton extends PixmapToggleButton implements ActionListener {
943     private final Channel channel;
944    
945     OptionsButton(Channel channel) {
946     super(Res.gfxOptionsOff, Res.gfxOptionsOn);
947    
948     this.channel = channel;
949    
950     setRolloverIcon(Res.gfxOptionsOffRO);
951     this.setRolloverSelectedIcon(Res.gfxOptionsOnRO);
952     addActionListener(this);
953     setToolTipText(i18n.getButtonLabel("Channel.ttShowOptions"));
954     }
955    
956     public void
957     actionPerformed(ActionEvent e) {
958     channel.showOptionsPane(isSelected());
959    
960     String s;
961     if(isSelected()) s = i18n.getButtonLabel("Channel.ttHideOptions");
962     else s = i18n.getButtonLabel("Channel.ttShowOptions");
963    
964     setToolTipText(s);
965     }
966    
967     public boolean
968     contains(int x, int y) { return super.contains(x, y) & y < 13; }
969     }
970 iliev 912 }
971    
972 iliev 1730 class ChannelOptionsPane extends JXCollapsiblePane {
973     ChannelOptionsPane() {
974 iliev 1285 setAnimated(false);
975     setCollapsed(true);
976     setAnimated(preferences().getBoolProperty(ANIMATED));
977    
978     preferences().addPropertyChangeListener(ANIMATED, new PropertyChangeListener() {
979     public void
980     propertyChange(PropertyChangeEvent e) {
981     setAnimated(preferences().getBoolProperty(ANIMATED));
982     }
983     });
984 iliev 912 }
985    
986 iliev 1730 public void
987     showOptionsPane(boolean show) { setCollapsed(!show); }
988 iliev 912 }
  ViewVC Help
Powered by ViewVC