class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        
        QObject.connect(self.ui.pushButton, QtCore.SIGNAL('clicked()'), self.button1)
        
    def button1(self):
        print "button 1"
Beispiel #2
0
    def __init__(self, parent=None):
        super(MainForm, self).__init__(parent)
        
        self.utils = Utils();
        self.cache = ScaleCache();
        self.mapper = Mapper();
        
        self.scale_to_map = [];
        self.mapped_scale = {};
        self.transpose = 0;
        self.autoScale = False;

        self.ui = Ui_MainWindow();
        self.ui.setupUi(self);
        
        self.loadAvailableScales();
        self.loadInitScale();
        
        self.midi_in = None;
        self.midi_out = None;
        self.check_midi_ports();

        self.ui.statusBar.showMessage("Ready for rock'N'roll!",1000 * 20);
 def __init__(self, parent=None):
     QtGui.QWidget.__init__(self, parent)
     self.ui = Ui_MainWindow()
     self.ui.setupUi(self)
     
     self.audioOutput = Phonon.AudioOutput(Phonon.MusicCategory, self)
     self.metaInformationResolver = Phonon.MediaObject(self)
     self.mediaObject = Phonon.MediaObject(self)
     self.ui.seekSlider.setMediaObject(self.mediaObject)
     self.ui.volumeSlider.setAudioOutput(self.audioOutput)
     Phonon.createPath(self.mediaObject, self.audioOutput)
     
     self.ui.display_songname.setText('No song')
     self.ui.display_songname.setMargin(50)
     
     ##connecting signals
     self.connect(self.ui.button_play, QtCore.SIGNAL('pressed()'),self.playPause)
     self.connect(self.ui.button_next, QtCore.SIGNAL('pressed()'),self.playNext)
     self.connect(self.ui.button_previous, QtCore.SIGNAL('pressed()'),self.playPrevious)
     self.connect(self.ui.actionExit, QtCore.SIGNAL('triggered()'),self.close)
     self.connect(self.ui.actionOpen, QtCore.SIGNAL('triggered()'),self.openFile)
     self.connect(self.ui.actionAdd_Directory, QtCore.SIGNAL('triggered()'),self.openDir)
     self.connect(self.mediaObject, QtCore.SIGNAL("metaDataChanged()"),self.updateData)
     self.connect(self.mediaObject, QtCore.SIGNAL("aboutToFinish()"),self.queueSong)
     self.connect(self.ui.playlist, QtCore.SIGNAL("itemDoubleClicked(QListWidgetItem*)"),self.playSelected)
     self.connect(self.ui.checkShuffle, QtCore.SIGNAL("stateChanged(int)"),self.playlistShuffle)
     self.connect(self.ui.button_add_s, QtCore.SIGNAL('pressed()'),self.openFile)
     self.connect(self.ui.button_add_d, QtCore.SIGNAL('pressed()'),self.openDir)
     self.connect(self.ui.button_rmv_s, QtCore.SIGNAL('pressed()'),self.removeFile)
     self.connect(self.ui.button_move_up, QtCore.SIGNAL('pressed()'),self.moveUp)
     self.connect(self.ui.button_move_down, QtCore.SIGNAL('pressed()'),self.moveDown)
     self.connect(self.ui.button_move_upup, QtCore.SIGNAL('pressed()'),self.moveUpUp)
     self.connect(self.ui.button_move_downdown, QtCore.SIGNAL('pressed()'),self.moveDownDown)
     
     self.filename=""
     self.playlist = []
     self.current_song = 0
class StartQT4(QtGui.QMainWindow):
    def __init__(self, parent=None):
        QtGui.QWidget.__init__(self, parent)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        
        self.audioOutput = Phonon.AudioOutput(Phonon.MusicCategory, self)
        self.metaInformationResolver = Phonon.MediaObject(self)
        self.mediaObject = Phonon.MediaObject(self)
        self.ui.seekSlider.setMediaObject(self.mediaObject)
        self.ui.volumeSlider.setAudioOutput(self.audioOutput)
        Phonon.createPath(self.mediaObject, self.audioOutput)
        
        self.ui.display_songname.setText('No song')
        self.ui.display_songname.setMargin(50)
        
        ##connecting signals
        self.connect(self.ui.button_play, QtCore.SIGNAL('pressed()'),self.playPause)
        self.connect(self.ui.button_next, QtCore.SIGNAL('pressed()'),self.playNext)
        self.connect(self.ui.button_previous, QtCore.SIGNAL('pressed()'),self.playPrevious)
        self.connect(self.ui.actionExit, QtCore.SIGNAL('triggered()'),self.close)
        self.connect(self.ui.actionOpen, QtCore.SIGNAL('triggered()'),self.openFile)
        self.connect(self.ui.actionAdd_Directory, QtCore.SIGNAL('triggered()'),self.openDir)
        self.connect(self.mediaObject, QtCore.SIGNAL("metaDataChanged()"),self.updateData)
        self.connect(self.mediaObject, QtCore.SIGNAL("aboutToFinish()"),self.queueSong)
        self.connect(self.ui.playlist, QtCore.SIGNAL("itemDoubleClicked(QListWidgetItem*)"),self.playSelected)
        self.connect(self.ui.checkShuffle, QtCore.SIGNAL("stateChanged(int)"),self.playlistShuffle)
        self.connect(self.ui.button_add_s, QtCore.SIGNAL('pressed()'),self.openFile)
        self.connect(self.ui.button_add_d, QtCore.SIGNAL('pressed()'),self.openDir)
        self.connect(self.ui.button_rmv_s, QtCore.SIGNAL('pressed()'),self.removeFile)
        self.connect(self.ui.button_move_up, QtCore.SIGNAL('pressed()'),self.moveUp)
        self.connect(self.ui.button_move_down, QtCore.SIGNAL('pressed()'),self.moveDown)
        self.connect(self.ui.button_move_upup, QtCore.SIGNAL('pressed()'),self.moveUpUp)
        self.connect(self.ui.button_move_downdown, QtCore.SIGNAL('pressed()'),self.moveDownDown)
        
        self.filename=""
        self.playlist = []
        self.current_song = 0
    
    ##move audiofile to the bottm of the list
    def moveDownDown(self):
        if self.ui.playlist.row(self.ui.playlist.selectedItems()[0]) != self.ui.playlist.count()-1:
            self.ui.playlist.insertItem(self.ui.playlist.count()-1,self.ui.playlist.takeItem(self.ui.playlist.row(self.ui.playlist.selectedItems()[0])))
            self.ui.playlist.setCurrentItem(self.ui.playlist.item(self.ui.playlist.count()-1))
            if self.ui.checkShuffle.checkState() == 0:
                self.c_song_name = self.playlist[self.current_song]
                self.playlist = []
                i = 0
                while i != self.ui.playlist.count():
                    self.playlist.append(self.ui.playlist.item(i).text())            
                    i = i + 1
                self.current_song = self.playlist.index(self.c_song_name)
        else:
            pass
        self.mediaObject.clearQueue()
        
    ##move audiofile to the top of the list
    def moveUpUp(self):
        if self.ui.playlist.row(self.ui.playlist.selectedItems()[0]) != 0:
            self.ui.playlist.insertItem(0,self.ui.playlist.takeItem(self.ui.playlist.row(self.ui.playlist.selectedItems()[0])))
            self.ui.playlist.setCurrentItem(self.ui.playlist.item(0))
            if self.ui.checkShuffle.checkState() == 0:
                self.c_song_name = self.playlist[self.current_song]
                self.playlist = []
                i = 0
                while i != self.ui.playlist.count():
                    self.playlist.append(self.ui.playlist.item(i).text())            
                    i = i + 1
                self.current_song = self.playlist.index(self.c_song_name)
        else:
            pass
        self.mediaObject.clearQueue()
    
    ##move audiofile a position down in list
    def moveDown(self):
        if self.ui.playlist.row(self.ui.playlist.selectedItems()[0]) != self.ui.playlist.count()-1:
            self.ui.playlist.insertItem((self.ui.playlist.row(self.ui.playlist.selectedItems()[0])+1),self.ui.playlist.takeItem(self.ui.playlist.row(self.ui.playlist.selectedItems()[0])))
            self.ui.playlist.setCurrentItem(self.ui.playlist.item(self.ui.playlist.row(self.ui.playlist.selectedItems()[0])+1))
            if self.ui.checkShuffle.checkState() == 0:
                self.c_song_name = self.playlist[self.current_song]
                self.playlist = []
                i = 0
                while i != self.ui.playlist.count():
                    self.playlist.append(self.ui.playlist.item(i).text())            
                    i = i + 1
                self.current_song = self.playlist.index(self.c_song_name)
        else:
            pass
        self.mediaObject.clearQueue()
    
    ##move audiofile a position up in list
    def moveUp(self):
        if self.ui.playlist.row(self.ui.playlist.selectedItems()[0]) != 0:
            self.ui.playlist.insertItem((self.ui.playlist.row(self.ui.playlist.selectedItems()[0])-1),self.ui.playlist.takeItem(self.ui.playlist.row(self.ui.playlist.selectedItems()[0])))
            self.ui.playlist.setCurrentItem(self.ui.playlist.item(self.ui.playlist.row(self.ui.playlist.selectedItems()[0])-2))
            if self.ui.checkShuffle.checkState() == 0:
                self.c_song_name = self.playlist[self.current_song]
                self.playlist = []
                i = 0
                while i != self.ui.playlist.count():
                    self.playlist.append(self.ui.playlist.item(i).text())            
                    i = i + 1
                self.current_song = self.playlist.index(self.c_song_name)
        else:
            pass
        self.mediaObject.clearQueue()
        
    
    ##remove audiofile from list
    def removeFile(self):
        song = self.ui.playlist.selectedItems()[0]
        
        self.playlist.remove(unicode(song.text()))
        self.ui.playlist.takeItem(self.ui.playlist.row(song))
        self.mediaObject.clearQueue()

    ##check shuffle
    def playlistShuffle(self):
        if self.ui.checkShuffle.checkState() == 2:
            random.shuffle(self.playlist)
        if self.ui.checkShuffle.checkState() == 0:
            self.c_song_name = self.playlist[self.current_song]
            self.playlist = []
            i = 0
            while i != self.ui.playlist.count()-1:
                self.playlist.append(self.ui.playlist.item(i).text())            
                i = i + 1
            self.current_song = self.playlist.index(self.c_song_name)
        self.mediaObject.clearQueue()
    
    ##on double-click playing
    def playSelected(self):
        self.selected = unicode(self.ui.playlist.selectedItems()[0].text())
        self.current_song = self.playlist.index(self.selected)
        try:
            self.mediaObject.setCurrentSource(Phonon.MediaSource(unicode(self.playlist[self.current_song])))
            self.mediaObject.play()
        except:
            self.playNext()
        self.mediaObject.clearQueue()
        if self.ui.checkShuffle.checkState() != 0:
            random.shuffle(self.playlist)
            
    ##queueing next song
    def queueSong(self):
        self.next_song = self.current_song + 1
        if self.playlist.__len__() <= self.next_song:
            self.next_song = 0

        self.mediaObject.enqueue(Phonon.MediaSource(unicode(self.playlist[self.next_song])))
    
    ##updating song data
    def updateData(self):
        self.artist = unicode(self.mediaObject.metaData().get(QtCore.QString('ARTIST'), [QtCore.QString()])[0])
        self.title = unicode(self.mediaObject.metaData().get(QtCore.QString('TITLE'), [QtCore.QString()])[0])
    
        self.ui.display_songname.setText(self.artist + ' - ' + self.title)
        self.mediaObject.clearQueue()
        
        self.playing_item = self.ui.playlist.findItems(unicode(self.mediaObject.currentSource().fileName()), QtCore.Qt.MatchExactly)
        self.ui.playlist.setCurrentItem(self.playing_item[0])
    
    ##close player
    def close(self):
        sys.exit()
    
    ##opening file or directory
    def openFile(self):
        self.filenames = QtGui.QFileDialog.getOpenFileNames(self, 'Open File')

        for filename in self.filenames:
            self.playlist.append(filename)
            self.ui.playlist.addItem(filename)
        self.mediaObject.clearQueue()
        if self.ui.checkShuffle.checkState() != 0:
            random.shuffle(self.playlist)

    ##adding files from directory
    def openDir(self):
        self.dir = unicode(QtGui.QFileDialog.getExistingDirectory(self, 'Add Directory'))
        
            
        dirs = []
        files = []
        for dirname, dirnames, filenames in os.walk(self.dir):
            dirs.append(dirname)
            for subdirname in dirnames:
                dirs.append(os.path.join(dirname, subdirname))
            for filename in filenames:
                files.append(os.path.join(dirname, filename)) 
                
        for x in files:
            self.playlist.append(x)
            self.ui.playlist.addItem(x)
        if self.ui.checkShuffle.checkState() != 0:
            random.shuffle(self.playlist)
    
    ##play/pause
    def playPause(self):
        if self.ui.playlist.selectedItems()[0] == None or unicode(self.ui.playlist.selectedItems()[0].text()) == unicode(self.playlist[self.current_song]):
            if self.mediaObject.state() == Phonon.PlayingState:
                self.mediaObject.pause()
            elif self.mediaObject.state() == Phonon.PausedState:
                self.mediaObject.play()
            else:
                if self.playlist != []:
                    self.mediaObject.setCurrentSource(Phonon.MediaSource(unicode(self.playlist[self.current_song])))
                else:
                    self.openFile()
                    self.current_song = 0
                    self.playPause()

                self.mediaObject.play()
        else:
            self.playSelected()
            
    ##next song
    def playNext(self):        
        self.current_song = self.current_song + 1
        if self.playlist.__len__() <= self.current_song:
            self.current_song = 0
        try:
            self.mediaObject.setCurrentSource(Phonon.MediaSource(unicode(self.playlist[self.current_song])))
            self.mediaObject.play()
        except:
            self.playNext()
        self.mediaObject.clearQueue()
    
    ##previous song
    def playPrevious(self):
        self.current_song = self.current_song - 1
        if self.current_song < 0:
            self.current_song = self.playlist.__len__() - 1
        try:
            self.mediaObject.setCurrentSource(Phonon.MediaSource(unicode(self.playlist[self.current_song])))
            self.mediaObject.play()
        except:
            self.playNext()
        self.mediaObject.clearQueue()
Beispiel #5
0
class MainForm(QtGui.QMainWindow):
    
    NOTE_OFF = 0x80
    NOTE_ON = 0x90

    def __init__(self, parent=None):
        super(MainForm, self).__init__(parent)
        
        self.utils = Utils();
        self.cache = ScaleCache();
        self.mapper = Mapper();
        
        self.scale_to_map = [];
        self.mapped_scale = {};
        self.transpose = 0;
        self.autoScale = False;

        self.ui = Ui_MainWindow();
        self.ui.setupUi(self);
        
        self.loadAvailableScales();
        self.loadInitScale();
        
        self.midi_in = None;
        self.midi_out = None;
        self.check_midi_ports();

        self.ui.statusBar.showMessage("Ready for rock'N'roll!",1000 * 20);
    
        
    def loadAvailableScales(self):
        for scale in self.utils.getAllAvailableScales():
            self.ui.listWidgetScales.addItem(scale);
            
    def loadInitScale(self):
        self.ui.listWidgetNotes.setCurrentRow(0);
        self.ui.listWidgetScales.setCurrentRow(0);
        result = self.cache.getScaleFromCache(str(self.ui.listWidgetNotes.item(0).text()),str(self.ui.listWidgetScales.item(0).text()));
        self.setNewScale(result);
    
                    
    @QtCore.pyqtSlot(str)
    def on_listWidgetScales_currentTextChanged(self, scale):
        currNote = self.ui.listWidgetNotes.currentItem();
        if currNote is not None:
            result = self.cache.getScaleFromCache(str(currNote.text()), str(scale));
            self.setNewScale(result);
            self.ui.statusBar.showMessage("Mapped scale: %s-%s"%(str(currNote.text()),str(scale)), 1000 * 5);

        
    @QtCore.pyqtSlot(str)
    def on_listWidgetNotes_currentTextChanged(self, note):
        currScale = self.ui.listWidgetScales.currentItem();
        if currScale is not None:
            result = self.cache.getScaleFromCache(str(note), str(currScale.text()));
            self.setNewScale(result);    
            self.autoScale = False;
            self.ui.pushButtonMagic.setChecked(False);
            self.ui.statusBar.showMessage("Mapped scale: %s-%s"%(str(note),str(currScale.text())), 1000 * 5);

            
    def setNewScale(self, scales):
        self.scale_to_map = scales['scale_to_map'];
        self.mapped_scale = scales['mapped_scale'];
        self.showOnKeys();
        
    def showOnKeys(self):
        for key in self.utils.getNotes():
            replacedKey = key.replace('#','S');
            if key in self.scale_to_map:
                new_state = True;               
            else:
                new_state = False;
            eval('self.ui.pushButton' + replacedKey + ".setChecked(" + str(new_state) + ")");
            
    def setNewKeyState(self, key, state):
        if state:
            self.scale_to_map.append(key);
            self.mapped_scale = self.mapper.getMap(self.scale_to_map);
        else:
            if key in self.scale_to_map:
                self.scale_to_map.remove(key);
                if len(self.scale_to_map) != 0:
                    self.mapped_scale = self.mapper.getMap(self.scale_to_map);
        
        self.autoScale = False;
        self.ui.pushButtonMagic.setChecked(False);
        self.ui.statusBar.showMessage("Custom scale: " + str(self.scale_to_map), 1000 * 5);
        
    @QtCore.pyqtSlot(bool)
    def on_pushButtonC_clicked(self, status):
        self.setNewKeyState('C', status);
        
    @QtCore.pyqtSlot(bool)
    def on_pushButtonCS_clicked(self, status):
        self.setNewKeyState('C#', status);
        
    @QtCore.pyqtSlot(bool)
    def on_pushButtonD_clicked(self, status):
        self.setNewKeyState('D', status);
        
    @QtCore.pyqtSlot(bool)
    def on_pushButtonDS_clicked(self, status):
        self.setNewKeyState('D#', status);
        
    @QtCore.pyqtSlot(bool)
    def on_pushButtonE_clicked(self, status):
        self.setNewKeyState('E', status);
        
    @QtCore.pyqtSlot(bool)
    def on_pushButtonF_clicked(self, status):
        self.setNewKeyState('F', status);
        
    @QtCore.pyqtSlot(bool)
    def on_pushButtonFS_clicked(self, status):
        self.setNewKeyState('F#', status);
        
    @QtCore.pyqtSlot(bool)
    def on_pushButtonG_clicked(self, status):
        self.setNewKeyState('G', status);
    
    @QtCore.pyqtSlot(bool)
    def on_pushButtonGS_clicked(self, status):
        self.setNewKeyState('G#', status);
        
    @QtCore.pyqtSlot(bool)
    def on_pushButtonA_clicked(self, status):
        self.setNewKeyState('A', status);
        
    @QtCore.pyqtSlot(bool)
    def on_pushButtonAS_clicked(self, status):
        self.setNewKeyState('A#', status);
        
    @QtCore.pyqtSlot(bool)
    def on_pushButtonB_clicked(self, status):
        self.setNewKeyState('B', status);
        
    @QtCore.pyqtSlot(int)
    def on_spinBoxTranspose_valueChanged(self, value):
        self.transpose = value;
        
    @QtCore.pyqtSlot()
    def on_pushButtonScan_clicked(self):
        self.check_midi_ports();
        
    def check_midi_ports(self):
        if self.midi_in is not None:
            self.midi_in.close_port();
        if self.midi_out is not None:
            self.midi_out.close_port();
        
        self.midi_in = rtmidi.MidiIn();
        self.midi_out = rtmidi.MidiOut();
        
        ports_in = self.midi_in.ports;
        ports_out = self.midi_out.ports;
        
        self.ui.listWidgetInput.clear();
        self.ui.listWidgetOutput.clear();
                
        if len(ports_in) == 0:
            self.ui.listWidgetInput.addItem("No input devices");
        else:
            for port_index in range(0, len(ports_in)):
                self.ui.listWidgetInput.addItem(ports_in[port_index]);
            self.on_listWidgetInput_currentRowChanged(0);
               
        if len(ports_out) == 0:
            self.ui.listWidgetOutput.addItem("No input devices");
        else:
            for port_index in range(0, len(ports_out)):
                self.ui.listWidgetOutput.addItem(ports_out[port_index]);
            self.on_listWidgetOutput_currentRowChanged(0);
            
        self.ui.statusBar.showMessage("Scan completed!",1000*5);
            
    @QtCore.pyqtSlot(bool)
    def on_pushButtonMagic_clicked(self, state):
        self.autoScale = state;
        self.ui.statusBar.showMessage("Magic mode: %s"%(state),1000*5);
        
    @QtCore.pyqtSlot()
    def on_pushButtonPanic_clicked(self):
        message = [self.NOTE_OFF,0,0];
        for i in range(0, 127):
            message[1] = i;
            self.midi_out.send_message(message);
            
    @QtCore.pyqtSlot(int)
    def on_listWidgetInput_currentRowChanged(self, port):
        self.midi_in.close_port();
        self.midi_in.open_port(port);
        self.midi_in.callback = self.midi_callback
        self.ui.statusBar.showMessage("%s port opened!"%(self.ui.listWidgetInput.item(port).text()),1000*5);
            
    @QtCore.pyqtSlot(int)
    def on_listWidgetOutput_currentRowChanged(self, port):
        self.midi_out.close_port();
        self.midi_out.open_port(port);
        self.ui.statusBar.showMessage("%s port opened!"%(self.ui.listWidgetOutput.item(port).text()),1000*5);

        
    def midi_callback(self, message, time_stamp):
        event_types = (self.NOTE_ON, self.NOTE_OFF)
        if (message[0] & 0xF0) in event_types:
            if self.autoScale:
                if(message[1] < 60):
                    note_scale = self.utils.getNoteAndOctave(message[1]);
                    scale = str(self.ui.listWidgetScales.currentItem().text());
                    
                    result = self.cache.getScaleFromCache(note_scale[0], scale);
                    self.scale_to_map = result['scale_to_map'];
                    self.mapped_scale = result['mapped_scale'];
                
                    #self.ui.statusBar.showMessage("Magic mode scale:%s-%s"%(note_scale[0],scale),1000*5);
                    self.midi_out.send_message(message);
                else:
                    self.send_modif_massage(message);
            else:
                self.send_modif_massage(message);
        else:
            self.midi_out.send_message(message);
            
    def send_modif_massage(self, message):
        note_octave = self.utils.getNoteAndOctave(message[1]);
        message[1] = self.utils.getMidiNumber(self.mapped_scale[note_octave[0]], note_octave[1]);
        message[1] += self.transpose;
        self.midi_out.send_message(message);
    
    @QtCore.pyqtSlot()
    def on_pushButtonExit_clicked(self):
        self.closeOpenPorts();
        self.close();
        
    def closeOpenPorts(self):
        if self.midi_in is not None:
            self.midi_in.close_port();
        if self.midi_out is not None:
            self.midi_out.close_port();
            
    def __exit__(self):
        self.closeOpenPorts();
 def __init__(self, parent=None):
     super(MainWindow, self).__init__(parent)
     self.ui = Ui_MainWindow()
     self.ui.setupUi(self)
     
     QObject.connect(self.ui.pushButton, QtCore.SIGNAL('clicked()'), self.button1)