def initializeWindow(self):
layout = QVBoxLayout()
self.m_deviceBox = QComboBox(activated=self.deviceChanged)
for deviceInfo in QAudioDeviceInfo.availableDevices(QAudio.AudioOutput):
self.m_deviceBox.addItem(deviceInfo.deviceName(), deviceInfo)
layout.addWidget(self.m_deviceBox)
self.m_modeButton = QPushButton(clicked=self.toggleMode)
self.m_modeButton.setText(self.PUSH_MODE_LABEL)
layout.addWidget(self.m_modeButton)
self.m_suspendResumeButton = QPushButton(
clicked=self.toggleSuspendResume)
self.m_suspendResumeButton.setText(self.SUSPEND_LABEL)
layout.addWidget(self.m_suspendResumeButton)
volumeBox = QHBoxLayout()
volumeLabel = QLabel("Volume:")
self.m_volumeSlider = QSlider(Qt.Horizontal, minimum=0, maximum=100,
singleStep=10, valueChanged=self.volumeChanged)
volumeBox.addWidget(volumeLabel)
volumeBox.addWidget(self.m_volumeSlider)
layout.addLayout(volumeBox)
window = QWidget()
window.setLayout(layout)
self.setCentralWidget(window)
def initializeWindow(self):
layout = QVBoxLayout()
self.m_deviceBox = QComboBox(activated=self.deviceChanged)
for deviceInfo in QAudioDeviceInfo.availableDevices(QAudio.AudioOutput):
self.m_deviceBox.addItem(deviceInfo.deviceName(), deviceInfo)
layout.addWidget(self.m_deviceBox)
self.m_modeButton = QPushButton(clicked=self.toggleMode)
self.m_modeButton.setText(self.PUSH_MODE_LABEL)
layout.addWidget(self.m_modeButton)
self.m_suspendResumeButton = QPushButton(
clicked=self.toggleSuspendResume)
self.m_suspendResumeButton.setText(self.SUSPEND_LABEL)
layout.addWidget(self.m_suspendResumeButton)
volumeBox = QHBoxLayout()
volumeLabel = QLabel("Volume:")
self.m_volumeSlider = QSlider(Qt.Horizontal, minimum=0, maximum=100,
singleStep=10, valueChanged=self.volumeChanged)
volumeBox.addWidget(volumeLabel)
volumeBox.addWidget(self.m_volumeSlider)
layout.addLayout(volumeBox)
window = QWidget()
window.setLayout(layout)
self.setCentralWidget(window)
def __init__(self, parent=None):
super().__init__(parent) #调用父类构造函数，创建窗体
self.ui=Ui_MainWindow() #创建UI对象
self.ui.setupUi(self) #构造UI界面
self.ui.progBar_Max.setMaximum(256)
self.ui.progBar_Min.setMaximum(256)
self.ui.progBar_Diff.setMaximum(256)
self.ui.sliderVolumn.setMaximum(100)
self.ui.sliderVolumn.setValue(100)
self.ui.comboDevices.clear()
self.__deviceList=QAudioDeviceInfo.availableDevices(QAudio.AudioInput) #音频输入设备列表
for i in range(len(self.__deviceList)):
device=self.__deviceList[i] #QAudioDeviceInfo类
self.ui.comboDevices.addItem(device.deviceName())
## self.__deviceInfo =None #当前设备信息,QAudioDeviceInfo
self.audioDevice=None #音频输入设备,QAudioInput
self.BUFFER_SIZE=4000
self.ioDevice=None #第1种读取方法，内建的IODevice
## self.externalReader=None #第2种读取方法，外建的IODevice
self.recordFile=QFile() #第3种读取方法，使用QFile直接写入文件
if len(self.__deviceList)>0:
self.ui.comboDevices.setCurrentIndex(0) #触发comboDevices的信号currentIndexChanged()
## self.__deviceInfo =deviceList[0]
else:
self.ui.actStart.setEnabled(False)
self.ui.actDeviceTest.setEnabled(False)
self.ui.groupBoxDevice.setTitle("支持的音频输入设置(无设备)")
def setupUi(self, MainWindow):
self.threadpool = QtCore.QThreadPool()
MainWindow.setObjectName("MainWindow")
sizeObject = QtWidgets.QDesktopWidget().screenGeometry(-1)
H = (sizeObject.height())
W = (sizeObject.width())
self.W = W
self.H = H
MainWindow.resize(W//8, H//10)
MainWindow.setMinimumSize(QtCore.QSize(W//5, H//7))
MainWindow.setAcceptDrops(True)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.gridLayout = QtWidgets.QGridLayout(self.centralwidget)
self.gridLayout.setObjectName("gridLayout")
self.comboBox = QtWidgets.QComboBox(self.centralwidget)
self.comboBox.setObjectName("comboBox")
self.comboBox.addItem('')
self.cmd = ""
""" AUDIO and VIDIO DEVICES """
from PyQt5.QtMultimedia import QAudioDeviceInfo, QAudio, QCameraInfo
# List of Audio Input Devices
input_audio_deviceInfos = QAudioDeviceInfo.availableDevices(
QAudio.AudioInput)
for device in input_audio_deviceInfos:
self.comboBox.addItem(device.deviceName())
""" ---------------------- """
self.comboBox.setCurrentIndex(1)
self.Mic = input_audio_deviceInfos[0].deviceName()
self.gridLayout.addWidget(self.comboBox, 1, 0, 1, 1)
self.radioButton = QtWidgets.QRadioButton(self.centralwidget)
self.radioButton.setObjectName("radioButton")
self.gridLayout.addWidget(self.radioButton, 2, 0, 1, 1)
self.pushButton = QtWidgets.QPushButton(self.centralwidget)
self.pushButton.setMinimumSize(QtCore.QSize(0, 23))
self.pushButton.setIconSize(QtCore.QSize(16, 25))
self.pushButton.setObjectName("pushButton")
self.gridLayout.addWidget(self.pushButton, 3, 0, 1, 1)
MainWindow.setCentralWidget(self.centralwidget)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.actionNew = QtWidgets.QAction(MainWindow)
self.actionNew.setObjectName("actionNew")
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
self.clicked = False
self.pushButton.clicked.connect(self.takeSnapNow)
self.radioButton.toggled.connect(self.setStatus)
self.comboBox.currentIndexChanged[str].connect(self.setAudioDevice)
self.th = {}
self.cap = ""
self.useCam = False
self.st = 0
self.arguments = ''
self.process = None
def modeChanged(self, idx: int) -> None:
self.testResult.clear()
self.deviceBox.clear()
mode = QAudio.AudioInput if idx == 0 else QAudio.AudioOutput
for deviceInfo in QAudioDeviceInfo.availableDevices(mode):
self.deviceBox.addItem(deviceInfo.deviceName(), deviceInfo)
self.deviceBox.setCurrentIndex(0)
self.deviceChanged(0)
def update_info_choices(self):
if self.behaviour_play_button == self.behaviour_play_button_restart:
self.behaviour_tab.option_play_button.radio_restart.setChecked(
True)
else:
self.behaviour_tab.option_play_button.radio_nothing.setChecked(
True)
if self.behaviour_playlist_autoplay == self.behaviour_playlist_autoplay_start:
self.behaviour_tab.option_playlist_autoplay.radio_autoplay.setChecked(
True)
else:
self.behaviour_tab.option_playlist_autoplay.radio_no_autoplay.setChecked(
True)
self.behaviour_tab.option_scrolling_text.spin_millisecond.setValue(
self.mainwindow.options.get_default_option(
self.mainwindow.options.default_user_timer_interval,
self.mainwindow.options.default_app_timer_interval))
self.audio_tab.option_output_device.label_selected_device.setToolTip(
self.mainwindow.options.get_default_output_device())
self.audio_tab.option_output_device.label_selected_device.setText(
"Current: {}".format(
self.mainwindow.options.get_default_output_device()))
self.audio_tab.option_output_device.combo_box_selected_device.clear()
for device in QAudioDeviceInfo.availableDevices(QAudio.AudioOutput):
self.audio_tab.option_output_device.combo_box_selected_device.addItem(
device.deviceName())
if self.audio_tab.option_output_device.combo_box_selected_device.count(
) == len(QAudioDeviceInfo.availableDevices(
QAudio.AudioOutput)) / 2:
self.audio_tab.option_output_device.combo_box_selected_device.addItem(
self.mainwindow.options.default_app_output_device)
break
for text, index in util.get_all_combo_box_items(
self.audio_tab.option_output_device.combo_box_selected_device):
if text == self.mainwindow.options.get_default_output_device():
self.audio_tab.option_output_device.combo_box_selected_device.setCurrentIndex(
index)
def modeChanged(self, idx):
self.testResult.clear()
if idx == 0:
self.mode = QAudio.AudioInput
else:
self.mode = QAudio.AudioOutput
self.deviceBox.clear()
for deviceInfo in QAudioDeviceInfo.availableDevices(self.mode):
self.deviceBox.addItem(deviceInfo.deviceName(), deviceInfo)
self.deviceBox.setCurrentIndex(0)
self.deviceChanged(0)
def modeChanged(self, idx):
self.testResult.clear()
if idx == 0:
self.mode = QAudio.AudioInput
else:
self.mode = QAudio.AudioOutput
self.deviceBox.clear()
for deviceInfo in QAudioDeviceInfo.availableDevices(self.mode):
self.deviceBox.addItem(deviceInfo.deviceName(), deviceInfo)
self.deviceBox.setCurrentIndex(0)
self.deviceChanged(0)
def __init__(self, obj):
super().__init__(obj)
self.mode = None
self.colors = None
self.count = 0
# noinspection PyArgumentList
self.inputdevices = QAudioDeviceInfo.availableDevices(
QAudio.AudioInput)
self.input = None
if self.inputdevices:
self.changeinput(0)
self.stream = None
self.timer = QTimer()
# connections
# noinspection PyUnresolvedReferences
self.timer.timeout.connect(self.setcolorinterrupt)
self.main.ui.plainTextEdit_bitdetector.textChanged.connect(
self.checkinput)
self.main.ui.comboBox_input.currentIndexChanged.connect(
self.changeinput)
self.main.ui.comboBox_effect_music.currentIndexChanged.connect(
self.changetextedit)
self.main.ui.pushButton_color_low.clicked.connect(self.colorselector)
self.main.ui.pushButton_color_mid.clicked.connect(self.colorselector)
self.main.ui.pushButton_color_high.clicked.connect(self.colorselector)
self.main.ui.verticalSlider_lower_low.valueChanged.connect(
self.changeslider)
self.main.ui.verticalSlider_lower_mid.valueChanged.connect(
self.changeslider)
self.main.ui.verticalSlider_lower_high.valueChanged.connect(
self.changeslider)
self.main.ui.verticalSlider_higher_low.valueChanged.connect(
self.changeslider)
self.main.ui.verticalSlider_higher_mid.valueChanged.connect(
self.changeslider)
self.main.ui.verticalSlider_higher_high.valueChanged.connect(
self.changeslider)
self.main.ui.pushButton_sound_onoff.toggled.connect(
self.soundbuttononoff)
# update styles
effects = ['Smooth', 'Change', 'Flash', 'Strob']
self.main.ui.comboBox_effect_music.addItems(effects)
inputs = [i.deviceName() for i in self.inputdevices]
self.main.ui.comboBox_input.addItems(inputs)
self.updatebuttons()
def load(self):
"""
Load the settings
"""
self.auto_start_check_box.setChecked(
Settings().value(self.settings_section + '/media auto start'))
self.stream_cmd.setText(Settings().value(self.settings_section +
'/stream command'))
self.audio_edit.setText(Settings().value(self.settings_section +
'/audio'))
self.video_edit.setText(Settings().value(self.settings_section +
'/video'))
if not self.stream_cmd.text():
self.set_base_stream()
self.vlc_arguments_edit.setPlainText(
Settings().value(self.settings_section + '/vlc arguments'))
if Settings().value('advanced/experimental'):
# vlc.MediaPlayer().audio_output_device_enum()
for cam in QCameraInfo.availableCameras():
log.debug(cam.deviceName())
log.debug(cam.description())
for au in QAudioDeviceInfo.availableDevices(QAudio.AudioInput):
log.debug(au.deviceName())
def initUI(self):
# main window/layout
window = QWidget()
layout = QVBoxLayout()
# layout for audio device and sample rate selection
deviceLayout = QHBoxLayout()
# make audio device selection box and list of available devices
self.deviceBox = QComboBox()
defaultDeviceInfo = QAudioDeviceInfo.defaultInputDevice()
self.availableDevices = [defaultDeviceInfo]
self.availableDevices += QAudioDeviceInfo.availableDevices(
QAudio.AudioInput)
for device in self.availableDevices:
self.deviceBox.addItem(device.deviceName())
# make sample rate label and combobox
sRateLabel = QLabel("Sample rate:")
sRateLabel.setAlignment(Qt.AlignRight)
# user can choose between 44.1 and 48kHz (valid DetectorBank rates)
self.sRateBox = QComboBox()
self.sRateBox.addItem("44100")
self.sRateBox.addItem("48000")
self.sRateBox.setCurrentIndex(1)
# add device and sr widgets to device layout
deviceLayout.addWidget(self.deviceBox)
deviceLayout.addWidget(sRateLabel)
deviceLayout.addWidget(self.sRateBox)
# add device layout to main layout
layout.addLayout(deviceLayout)
# DetectorBank parameters layout
# two rows of three parameters
# each param needs label and edit,
# and a 'Start' button will be added at the bottom
# so grid should be 3x6
detBankParamLayout = QGridLayout()
# label and lineedit for each
bandwidthLabel = QLabel("Bandwidth (cents):")
dampingLabel = QLabel("Damping:")
gainLabel = QLabel("Gain:")
edoLabel = QLabel("EDO:")
lwrLabel = QLabel("Lower note:")
uprLabel = QLabel("Upper note:")
self.bandwidthEdit = QLineEdit("0")
self.dampingEdit = QLineEdit("0.0001")
self.gainEdit = QLineEdit("25")
self.edoEdit = QLineEdit("12")
self.lwrEdit = QLineEdit("A1")
self.uprEdit = QLineEdit("A7")
# store all in lists
detBankParamLabels = [bandwidthLabel, dampingLabel, gainLabel,
edoLabel, lwrLabel, uprLabel]
detBankParamEdits = [self.bandwidthEdit, self.dampingEdit,
self.gainEdit, self.edoEdit, self.lwrEdit,
self.uprEdit]
# fill first two rows of grid with labels and edits
row = 0
for row in range(2):
widgetNum = 0
for i in range((row*3), (row*3)+3):
detBankParamLayout.addWidget(detBankParamLabels[i], row,
widgetNum)
widgetNum += 1
detBankParamLayout.addWidget(detBankParamEdits[i], row,
widgetNum)
widgetNum += 1
# align labels to the right (next to the edit)
for i in range(len(detBankParamLabels)):
detBankParamLabels[i].setAlignment(Qt.AlignRight)
# button to make DetectorBank and start visualisation
row += 1
startButton = QPushButton("&Start!")
detBankParamLayout.addWidget(startButton, row, 5)
startButton.clicked.connect(self.start)
# add grid of detbank params (and start button) to main layout
layout.addLayout(detBankParamLayout)
window.setLayout(layout)
self.setCentralWidget(window)
self.show()
def stoprecording_func():
p.send_signal(signal.CTRL_C_EVENT)
start_record_btn.configure(state=tk.NORMAL)
screen_shot_btn.configure(state=tk.NORMAL)
browse_btn.configure(state=tk.NORMAL)
save_btn.configure(state=tk.NORMAL)
tk.messagebox.showinfo(
'Info', 'Recording file ->' + video_filename + '\nSaved at ->' +
entry_text.get())
screenshot_filename = 'screenshots_' + time.strftime("%Y%m%d-%H%M%S")
default_path = 'C:/Users/vikesh/Desktop'
doc_suffix = '.docx'
video_suffix = '.mp4'
input_audio_devices = QAudioDeviceInfo.availableDevices(QAudio.AudioInput)
devices = []
for device in input_audio_devices:
if device.deviceName() not in devices:
devices.append(device.deviceName())
document = Document()
window = tk.Tk()
window.configure(background='#767676')
window.resizable(width=False, height=False)
window.title('Recorder')
style = Style()
style.theme_use('clam')
style.configure('TButton',
font=('Segoe', 9, 'bold'),
def __init__(self):
super().__init__()
arguments = self.parseArguments()
self.DEBUG = arguments.debug
os.chdir(os.path.dirname(os.path.realpath(__file__)))
self.MIN_WIDTH = 600
self.MIN_HEIGHT = 350
self.setMinimumWidth(self.MIN_WIDTH)
self.setMinimumHeight(self.MIN_HEIGHT)
self.ROOT_FOLDER = os.path.expanduser("~/.florodoro/")
self.HISTORY_FILE_PATH = self.ROOT_FOLDER + "history" + ("" if not self.DEBUG else "-debug") + ".yaml"
self.CONFIGURATION_FILE_PATH = self.ROOT_FOLDER + "config" + ("" if not self.DEBUG else "-debug") + ".yaml"
self.history = History(self.HISTORY_FILE_PATH)
self.SOUNDS_FOLDER = "sounds/"
self.PLANTS_FOLDER = "plants/"
self.IMAGE_FOLDER = "images/"
self.TEXT_COLOR = self.palette().text().color()
self.BREAK_COLOR = "#B37700"
self.APP_NAME = "Florodoro"
self.STUDY_ICON = qtawesome.icon('fa5s.book', color=self.TEXT_COLOR)
self.BREAK_ICON = qtawesome.icon('fa5s.coffee', color=self.BREAK_COLOR)
self.CONTINUE_ICON = qtawesome.icon('fa5s.play', color=self.TEXT_COLOR)
self.PAUSE_ICON = qtawesome.icon('fa5s.pause', color=self.TEXT_COLOR)
self.RESET_ICON = qtawesome.icon('fa5s.undo', color=self.TEXT_COLOR)
self.PLANTS = [GreenTree, DoubleGreenTree, OrangeTree, CircularFlower]
self.PLANT_NAMES = ["Spruce", "Double spruce", "Maple", "Flower"]
self.WIDGET_SPACING = 10
self.MAX_TIME = 180
self.STEP = 5
self.INITIAL_TEXT = "Start!"
self.menuBar = QMenuBar(self)
self.presets_menu = self.menuBar.addMenu('&Presets')
self.presets = {
"Classic": (25, 5, 4),
"Extended": (45, 12, 2),
"Sitcomodoro": (65, 25, 1),
}
for name in self.presets:
study_time, break_time, cycles = self.presets[name]
self.presets_menu.addAction(
QAction(f"{name} ({study_time} : {break_time} : {cycles})", self,
triggered=partial(self.load_preset, study_time, break_time, cycles)))
self.DEFAULT_PRESET = "Classic"
self.options_menu = self.menuBar.addMenu('&Options')
self.notify_menu = self.options_menu.addMenu("&Notify")
self.sound_action = QAction("&Sound", self, checkable=True, checked=not self.DEBUG,
triggered=lambda _: self.volume_slider.setDisabled(
not self.sound_action.isChecked()))
self.notify_menu.addAction(self.sound_action)
# Default audio device
self.audio_device = QAudioDeviceInfo.defaultInputDevice()
# Create device menu
self.audio_device_menu = self.notify_menu.addMenu("&Audio Devices")
# For all sound devices, add a device check box to the device menu
audio_devices = QAudioDeviceInfo.availableDevices(QAudio.AudioOutput)
for device in audio_devices:
device_name = device.deviceName()
self.device_action = QAction(f"&{device_name}", self, checkable=True, checked=not self.DEBUG, triggered=partial(self.setAudioDevice, device))
# Create callback of some sort for clicking on the device in the menu
self.audio_device_menu.addAction(self.device_action)
self.volume_slider = QSlider(Qt.Horizontal, minimum=0, maximum=100, value=85)
slider_action = QWidgetAction(self)
slider_action.setDefaultWidget(SpacedQWidget(self.volume_slider))
self.notify_menu.addAction(slider_action)
self.popup_action = QAction("&Pop-up", self, checkable=True, checked=True)
self.notify_menu.addAction(self.popup_action)
self.menuBar.addAction(
QAction(
"&Statistics",
self,
triggered=lambda: self.statistics.show() if self.statistics.isHidden() else self.statistics.hide()
)
)
self.menuBar.addAction(
QAction(
"&About",
self,
triggered=lambda: QMessageBox.information(
self,
"About",
"This application was created by Tomáš Sláma. It is heavily inspired by the Android app Forest, "
"but with all of the plants generated procedurally. It's <a href='https://github.com/xiaoxiae/Florodoro'>open source</a> and licensed "
"under MIT, so do as you please with the code and anything else related to the project.",
),
)
)
self.plant_menu = self.options_menu.addMenu("&Plants")
self.overstudy_action = QAction("Overstudy", self, checkable=True)
self.options_menu.addAction(self.overstudy_action)
self.plant_images = []
self.plant_checkboxes = []
# dynamically create widgets for each plant
for plant, name in zip(self.PLANTS, self.PLANT_NAMES):
self.plant_images.append(tempfile.NamedTemporaryFile(suffix=".svg"))
tmp = plant()
tmp.set_max_age(1)
tmp.set_age(1)
tmp.save(self.plant_images[-1].name, 200, 200)
setattr(self.__class__, name,
QAction(self, icon=QIcon(self.plant_images[-1].name), text=name, checkable=True, checked=True))
action = getattr(self.__class__, name)
self.plant_menu.addAction(action)
self.plant_checkboxes.append(action)
# the current plant that we're growing
# if set to none, no plant is growing
self.plant = None
self.menuBar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum)
main_vertical_layout = QVBoxLayout(self)
main_vertical_layout.setContentsMargins(0, 0, 0, 0)
main_vertical_layout.setSpacing(0)
main_vertical_layout.addWidget(self.menuBar)
self.canvas = Canvas(self)
self.statistics = Statistics(self.history)
font = self.font()
font.setPointSize(100)
self.main_label = QLabel(self, alignment=Qt.AlignCenter)
self.main_label.setFont(font)
self.main_label.setText(self.INITIAL_TEXT)
font.setPointSize(26)
self.cycle_label = QLabel(self)
self.cycle_label.setAlignment(Qt.AlignTop)
self.cycle_label.setMargin(20)
self.cycle_label.setFont(font)
main_horizontal_layout = QHBoxLayout(self)
self.study_time_spinbox = QSpinBox(self, prefix="Study for: ", suffix="min.", minimum=1, maximum=self.MAX_TIME,
singleStep=self.STEP)
self.break_time_spinbox = QSpinBox(self, prefix="Break for: ", suffix="min.", minimum=1, maximum=self.MAX_TIME,
singleStep=self.STEP,
styleSheet=f'color:{self.BREAK_COLOR};')
self.cycles_spinbox = QSpinBox(self, prefix="Cycles: ", minimum=1, value=1)
# keep track of remaining number of cycles and the starting number of cycles
self.remaining_cycles = 0
self.total_cycles = 0
# whether we're currently studying
self.is_study_ongoing = False
# whether we notified the user already during overstudy
self.already_notified_during_overstudy = False
stacked_layout = QStackedLayout(self, stackingMode=QStackedLayout.StackAll)
stacked_layout.addWidget(self.main_label)
stacked_layout.addWidget(self.cycle_label)
stacked_layout.addWidget(self.canvas)
main_vertical_layout.addLayout(stacked_layout)
self.setStyleSheet("")
self.study_button = QPushButton(self, clicked=self.start, icon=self.STUDY_ICON)
self.break_button = QPushButton(self, clicked=self.start_break, icon=self.BREAK_ICON)
self.pause_button = QPushButton(self, clicked=self.toggle_pause, icon=self.PAUSE_ICON)
self.reset_button = QPushButton(self, clicked=self.reset, icon=self.RESET_ICON)
main_horizontal_layout.addWidget(self.study_time_spinbox)
main_horizontal_layout.addWidget(self.break_time_spinbox)
main_horizontal_layout.addWidget(self.cycles_spinbox)
main_horizontal_layout.addWidget(self.study_button)
main_horizontal_layout.addWidget(self.break_button)
main_horizontal_layout.addWidget(self.pause_button)
main_horizontal_layout.addWidget(self.reset_button)
main_vertical_layout.addLayout(main_horizontal_layout)
self.setLayout(main_vertical_layout)
self.study_timer_frequency = 1 / 60 * 1000
self.study_timer = QTimer(self, interval=int(self.study_timer_frequency), timeout=self.decrease_remaining_time)
self.player = QMediaPlayer(self)
self.setWindowIcon(QIcon(self.IMAGE_FOLDER + "icon.svg"))
self.setWindowTitle(self.APP_NAME)
# set initial UI state
self.reset()
# a list of name, getter and setter things to load/save when the app opens/closes
# also dynamically get settings for selecting/unselecting plants
self.CONFIGURATION_ATTRIBUTES = [("study-time", self.study_time_spinbox.value,
self.study_time_spinbox.setValue),
("break-time", self.break_time_spinbox.value,
self.break_time_spinbox.setValue),
("cycles", self.cycles_spinbox.value, self.cycles_spinbox.setValue),
("sound", self.sound_action.isChecked, self.sound_action.setChecked),
("sound-volume", self.volume_slider.value, self.volume_slider.setValue),
("pop-ups", self.popup_action.isChecked, self.popup_action.setChecked),
("overstudy", self.overstudy_action.isChecked,
self.overstudy_action.setChecked)] + \
[(name.lower(), getattr(self.__class__, name).isChecked,
getattr(self.__class__, name).setChecked) for _, name in
zip(self.PLANTS, self.PLANT_NAMES)]
# load the default preset
self.load_preset(*self.presets[self.DEFAULT_PRESET])
self.load_settings()
self.show()
def _uic(self):
'''
set up our layout which consists of:
Big Honkin' Label
[input combobox] [output combobox]
[volume slider] [x] Mute
Hooking the signals to useful slots is the job
of __init__. Here just make the layout.
'''
self.setMinimumWidth(400)
# Create the big honkin' label and logo
icon_pixmap = QPixmap(':/icon.png').scaledToWidth(64)
icon_label = QLabel()
icon_label.setPixmap(icon_pixmap)
text_label = QLabel("Sidetone!")
hb_label = QHBoxLayout()
hb_label.addStretch(1)
hb_label.addWidget(icon_label, 0)
hb_label.addWidget(text_label, 0)
hb_label.addStretch(1)
# Create a list of QAudioInfo objects for inputs
self.input_info_list = QAudioDeviceInfo.availableDevices(
QAudio.AudioInput)
if 0 == len(self.input_info_list):
self.input_info_list = [QAudioDeviceInfo.defaultInputDevice()]
# Make a list of the name-strings for those items.
in_dev_names = [
audio_info.deviceName() for audio_info in self.input_info_list
]
# Create a combo box and populate it with those names
self.cb_inputs = QComboBox()
self.cb_inputs.addItems(in_dev_names)
# If the in_dev_name from the previous run is in the current list,
# make it current, otherwise pick the first item.
in_dev_name = self.settings.value('in_dev_name', 'unknown')
if in_dev_name in in_dev_names:
self.cb_inputs.setCurrentIndex(in_dev_names.index(in_dev_name))
else:
self.cb_inputs.setCurrentIndex(0)
# Create a list of QAudioInfo objects for outputs
self.otput_info_list = QAudioDeviceInfo.availableDevices(
QAudio.AudioOutput)
if 0 == len(self.otput_info_list):
self.otput_info_list = [QAudioDeviceInfo.defaultOutputDevice()]
# Make a list of the name-strings of those things
ot_dev_names = [
audio_info.deviceName() for audio_info in self.otput_info_list
]
# Create a combo box and populate it with those names
self.cb_otputs = QComboBox()
self.cb_otputs.addItems(ot_dev_names)
# If the ot_dev_name from the previous run is in the current list,
# make it the current choice in the box.
ot_dev_name = self.settings.value('ot_dev_name', 'unknown')
if ot_dev_name in ot_dev_names:
self.cb_otputs.setCurrentIndex(ot_dev_names.index(ot_dev_name))
else:
self.cb_otputs.setCurrentIndex(0)
#self.show_status(
#'{} inputs {} otputs'.format(len(self.input_info_list),len(self.otput_info_list))
#)
# Create a combo box and populate it with names of outputs
# Lay those two out aligned to the outside
hb_combos = QHBoxLayout()
hb_combos.addWidget(self.cb_inputs, 1)
hb_combos.addStretch(0)
hb_combos.addWidget(self.cb_otputs, 1)
# Create a volume slider from 0 to 100.
self.volume = QSlider(Qt.Horizontal, self)
self.volume.setMinimum(0)
self.volume.setMaximum(100)
self.volume.setTickInterval(10)
self.volume.setTickPosition(QSlider.TicksBothSides)
# set the volume slider to the value from the previous run, or zero.
self.volume.setValue(self.settings.value('volume', 0))
# Create a checkbox "Mute"
self.mute = QCheckBox('Mute')
# Set it to the value at the end of the last run, or to True
self.mute.setChecked(bool(self.settings.value('mute_status', 1)))
# Put those together in a row squeezed in the center
hb_volume = QHBoxLayout()
hb_volume.addStretch(1)
hb_volume.addWidget(self.volume, 1)
hb_volume.addWidget(self.mute, 0)
hb_volume.addStretch(1)
# Stack all those up as this widget's layout
vlayout = QVBoxLayout()
vlayout.addLayout(hb_label)
vlayout.addLayout(hb_combos)
vlayout.addLayout(hb_volume)
self.setLayout(vlayout)
def get_audio_devices(self):
return QAudioDeviceInfo.availableDevices(QAudio.AudioOutput)
def _uic(self):
"""
set up our layout which consists of:
Big Honkin' Label
[input combobox] [output combobox]
[volume slider] [x] Mute
hooking put the signals to useful slots is the job
of __init__. Here just make the layout.
"""
self.setMinimumWidth(400)
# Create the big honkin' label and logo
icon_pixmap = QPixmap(":/icon.png").scaledToWidth(64)
icon_label = QLabel()
icon_label.setPixmap(icon_pixmap)
text_label = QLabel("Sidetone!")
hb_label = QHBoxLayout()
hb_label.addStretch(1)
hb_label.addWidget(icon_label, 0)
hb_label.addWidget(text_label, 0)
hb_label.addStretch(1)
# Create a list of QAudioInfo objects for inputs
self.input_info_list = QAudioDeviceInfo.availableDevices(QAudio.AudioInput)
if 0 == len(self.input_info_list):
self.input_info_list = [QAudioDeviceInfo.defaultInputDevice()]
# Create a combo box and populate it with names of inputs
self.cb_inputs = QComboBox()
self.cb_inputs.addItems([audio_info.deviceName() for audio_info in self.input_info_list])
# Create a list of QAudioInfo objects for outputs
self.otput_info_list = QAudioDeviceInfo.availableDevices(QAudio.AudioOutput)
if 0 == len(self.otput_info_list):
self.otput_info_list = [QAudioDeviceInfo.defaultOutputDevice()]
self.status_bar.showMessage(
"{} inputs {} otputs".format(len(self.input_info_list), len(self.otput_info_list)), 2000
)
# Create a combo box and populate it with names of outputs
self.cb_otputs = QComboBox()
self.cb_otputs.addItems([audio_info.deviceName() for audio_info in self.otput_info_list])
# Lay those two out aligned to the outside
hb_combos = QHBoxLayout()
hb_combos.addWidget(self.cb_inputs, 1)
hb_combos.addStretch(0)
hb_combos.addWidget(self.cb_otputs, 1)
# Create a volume slider from 0 to 100.
self.volume = QSlider(Qt.Horizontal, self)
self.volume.setMinimum(0)
self.volume.setMaximum(100)
self.volume.setTickInterval(10)
self.volume.setTickPosition(QSlider.TicksBothSides)
# Create a checkbox "Mute"
self.mute = QCheckBox("Mute")
# Put those together in a row squeezed in the center
hb_volume = QHBoxLayout()
hb_volume.addStretch(1)
hb_volume.addWidget(self.volume, 1)
hb_volume.addWidget(self.mute, 0)
hb_volume.addStretch(1)
# Stack all those up as this widget's layout
vlayout = QVBoxLayout()
vlayout.addLayout(hb_label)
vlayout.addLayout(hb_combos)
vlayout.addLayout(hb_volume)
self.setLayout(vlayout)
def _uic(self):
'''
set up our layout which consists of:
Big Honkin' Label
[input combobox] [output combobox]
[volume slider] [x] Mute
hooking put the signals to useful slots is the job
of __init__. Here just make the layout.
'''
self.setMinimumWidth(400)
# Create the big honkin' label and logo
icon_pixmap = QPixmap(':/icon.png').scaledToWidth(64)
icon_label = QLabel()
icon_label.setPixmap(icon_pixmap)
text_label = QLabel("Sidetone!")
hb_label = QHBoxLayout()
hb_label.addStretch(1)
hb_label.addWidget(icon_label, 0)
hb_label.addWidget(text_label, 0)
hb_label.addStretch(1)
# Create a list of QAudioInfo objects for inputs
self.input_info_list = QAudioDeviceInfo.availableDevices(
QAudio.AudioInput)
if 0 == len(self.input_info_list):
self.input_info_list = [QAudioDeviceInfo.defaultInputDevice()]
# Create a combo box and populate it with names of inputs
self.cb_inputs = QComboBox()
self.cb_inputs.addItems(
[audio_info.deviceName() for audio_info in self.input_info_list])
# Create a list of QAudioInfo objects for outputs
self.otput_info_list = QAudioDeviceInfo.availableDevices(
QAudio.AudioOutput)
if 0 == len(self.otput_info_list):
self.otput_info_list = [QAudioDeviceInfo.defaultOutputDevice()]
self.status_bar.showMessage(
'{} inputs {} otputs'.format(len(self.input_info_list),
len(self.otput_info_list)), 2000)
# Create a combo box and populate it with names of outputs
self.cb_otputs = QComboBox()
self.cb_otputs.addItems(
[audio_info.deviceName() for audio_info in self.otput_info_list])
# Lay those two out aligned to the outside
hb_combos = QHBoxLayout()
hb_combos.addWidget(self.cb_inputs, 1)
hb_combos.addStretch(0)
hb_combos.addWidget(self.cb_otputs, 1)
# Create a volume slider from 0 to 100.
self.volume = QSlider(Qt.Horizontal, self)
self.volume.setMinimum(0)
self.volume.setMaximum(100)
self.volume.setTickInterval(10)
self.volume.setTickPosition(QSlider.TicksBothSides)
# Create a checkbox "Mute"
self.mute = QCheckBox('Mute')
# Put those together in a row squeezed in the center
hb_volume = QHBoxLayout()
hb_volume.addStretch(1)
hb_volume.addWidget(self.volume, 1)
hb_volume.addWidget(self.mute, 0)
hb_volume.addStretch(1)
# Stack all those up as this widget's layout
vlayout = QVBoxLayout()
vlayout.addLayout(hb_label)
vlayout.addLayout(hb_combos)
vlayout.addLayout(hb_volume)
self.setLayout(vlayout)
