Browse Source

initial commit

tags/v0.1
Nils 1 year ago
parent
commit
c98efbd6d7
31 changed files with 6924 additions and 0 deletions
  1. +8
    -0
      argodejo
  2. +328
    -0
      engine/api.py
  3. +45
    -0
      engine/config.py
  4. +230
    -0
      engine/findprograms.py
  5. +1603
    -0
      engine/nsmservercontrol.py
  6. +33
    -0
      engine/old
  7. +220
    -0
      engine/start.py
  8. +154
    -0
      engine/watcher.py
  9. BIN
      icon.png
  10. +110
    -0
      qtgui/addclientprompt.py
  11. +99
    -0
      qtgui/descriptiontextwidget.py
  12. +356
    -0
      qtgui/designer/mainwindow.py
  13. +670
    -0
      qtgui/designer/mainwindow.ui
  14. +52
    -0
      qtgui/designer/newsession.py
  15. +110
    -0
      qtgui/designer/newsession.ui
  16. +45
    -0
      qtgui/designer/projectname.py
  17. +52
    -0
      qtgui/designer/projectname.ui
  18. +75
    -0
      qtgui/eventloop.py
  19. +181
    -0
      qtgui/helper.py
  20. +448
    -0
      qtgui/mainwindow.py
  21. +482
    -0
      qtgui/opensessioncontroller.py
  22. +160
    -0
      qtgui/projectname.py
  23. +321
    -0
      qtgui/quickopensessioncontroller.py
  24. +108
    -0
      qtgui/quicksessioncontroller.py
  25. +343
    -0
      qtgui/sessiontreecontroller.py
  26. +105
    -0
      qtgui/systemtray.py
  27. +76
    -0
      qtgui/waitdialog.py
  28. +292
    -0
      tools/nsm-data.py
  29. +1
    -0
      tools/nsmclient.py
  30. +216
    -0
      tools/nsmcmdline.py
  31. +1
    -0
      tools/nsmservercontrol.py

+ 8
- 0
argodejo View File

@@ -0,0 +1,8 @@
#! /usr/bin/env python3
# -*- coding: utf-8 -*-

from engine import start

from qtgui import mainwindow #which in turn imports the engine and starts the engine
mainwindow.MainWindow()
#Program is over. Code here does not get executed.

+ 328
- 0
engine/api.py View File

@@ -0,0 +1,328 @@
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Copyright 2020, Nils Hilbricht, Germany ( https://www.hilbricht.net )

This file is part of the Laborejo Software Suite ( https://www.laborejo.org )

The Template Base Application is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""


import logging; logger = logging.getLogger(__name__); logger.info("import")

#Standard Library

#Our Modules
from engine.start import PATHS

from .nsmservercontrol import NsmServerControl
from .watcher import Watcher
from .findprograms import programDatabase

class Callbacks(object):
"""GUI methods register themselves here.
These methods get called by us, the engine.

None of these methods produce any return value.

The lists may be unordered.

We need the lists for audio feedbacks in parallel to GUI updates.
Or whatever parallel representations we run."""

def __init__(self):
self.message = []

#Session Management
self.sessionOpenReady = []
self.sessionOpenLoading = []
self.sessionClosed = []
self.sessionsChanged = [] #update in the file structure. redraw list of sessions.
self.sessionLocked = [] # incremental update. Sends the name of the session project and a bool if locked
self.sessionFileChanged = [] #incremental update. Reports the session name, not the session file
self.clientStatusChanged = [] #every status including GUI and dirty
self.singleInstanceActivateWindow = [] #this is for the single-instance feature. Show the GUI window and activate it when this signal comes.
self.dataClientNamesChanged = []
self.dataClientDescriptionChanged = []

def _dataClientNamesChanged(self, data):
"""If there is a dataclient in the session it will allow us to read and write metadata.
The GUI instructs us to send a write instruction over OSC, we wait for the OSC answer
and forward that to the GUI.
If the dataClient joins the session it will trigger an unrequested callback (from the GUIs
perspectvive). If the client leaves the callback will send a single None. This is a sign
for the GUI to reset all data to the nsmd state. We do not mix nsmd data and dataClient. A
dataclient can join and leave at every time, we keep the GUI informed. """
for func in self.dataClientNamesChanged:
func(data)
def _dataClientDescriptionChanged(self, data):
"""see _dataClientNamesChanged.
In short: str for data, None if nsm-data leaves session"""
for func in self.dataClientDescriptionChanged:
func(data)

def _singleInstanceActivateWindow(self):
for func in self.singleInstanceActivateWindow:
func()

def _sessionOpenReady(self, nsmSessionExportDict):
"""A project got opened, most likely by ourselves, but also by another party.
This will also fire if we start and detect that a session is already open and running.
"""
for func in self.sessionOpenReady:
func(nsmSessionExportDict)

def _sessionOpenLoading(self, nsmSessionExportDict):
"""
A session begins loading. Show a spinning clock or so...
"""
for func in self.sessionOpenLoading:
func(nsmSessionExportDict)

def _sessionClosed(self):
"""The current session got closed. Present a list of sessions to choose from again.
This is also send at GUI start if there is no session open presently."""
for func in self.sessionClosed:
func()

def _sessionsChanged(self):
"""The project list changed.
This can happen through internal changes like deletion or duplication
but also through external changes through a filemanager.

Always sends a full update of everything, with no indication of what changed."""
listOfProjectDicts = nsmServerControl.exportSessionsAsDicts()
for func in self.sessionsChanged:
func(listOfProjectDicts)

return listOfProjectDicts
def _sessionLocked(self, name:str, status:bool):
"""Called by the Watcher through the event loop
Name is "nsmSessionName" from _nsmServerControl.exportSessionsAsDicts
Sends True if project is locked"""
for func in self.sessionLocked:
func(name, status)

def _sessionFileChanged(self, name:str, timestamp:str):
"""
This happens everytime the session gets saved.

Called by the Watcher through the event loop.
Name is "nsmSessionName" from _nsmServerControl.exportSessionsAsDicts.
timestamp has same format as nsmServerControl.exportSessionsAsDicts"""
for func in self.sessionFileChanged:
func(name, timestamp)

def _clientStatusChanged(self, clientInfoDict:dict):
"""A single function for all client changes. Adding and deletion is also included.
GUI hide/show and dirty is also here.
A GUI needs to check if it already knows the clientId or not."""
for func in self.clientStatusChanged:
func(clientInfoDict)


def startEngine():
logger.info("Start Engine")

global eventLoop
assert eventLoop
global nsmServerControl
nsmServerControl = NsmServerControl(
sessionOpenReadyHook=callbacks._sessionOpenReady,
sessionOpenLoadingHook=callbacks._sessionOpenLoading,
sessionClosedHook=callbacks._sessionClosed,
clientStatusHook=callbacks._clientStatusChanged,
singleInstanceActivateWindowHook=callbacks._singleInstanceActivateWindow,
dataClientNamesHook=callbacks._dataClientNamesChanged,
dataClientDescriptionHook=callbacks._dataClientDescriptionChanged,
parameterNsmOSCUrl=PATHS["url"],
sessionRoot=PATHS["sessionRoot"],
)

#Watch session tree for changes.
global sessionWatcher
sessionWatcher = Watcher(nsmServerControl)
sessionWatcher.timeStampHook = callbacks._sessionFileChanged
sessionWatcher.lockFileHook = callbacks._sessionLocked
sessionWatcher.sessionsChangedHook = callbacks._sessionsChanged #This is the main callback that informs of new or updated sessions
callbacks.sessionClosed.append(sessionWatcher.resume) #Watcher only active in "Choose a session mode"
callbacks.sessionOpenReady.append(sessionWatcher.suspend)
eventLoop.slowConnect(sessionWatcher.process)

#Start Event Loop Processing
eventLoop.fastConnect(nsmServerControl.process)
eventLoop.slowConnect(nsmServerControl.processSingleInstance)
#Send initial data
#The decision if we are already in a session on startup or in "choose a session mode" is handled by callbacks
#This is not to actually gather the data, but only to inform the GUI.
callbacks._sessionsChanged()

#nsmServerControl blocks until it has a connection to nsmd. That means at this point we are ready to send commands.
#Until we return from startEngine a GUI will also not create its mainwindow. This can be used to create the appearance
#of a session-on-load:
if PATHS["startupSession"]:
sessionOpen(PATHS["startupSession"])
#Info
def sessionRoot():
return nsmServerControl.sessionRoot

def currentSession():
return nsmServerControl.internalState["currentSession"]

def sessionList():
"""Updates the list each call. Use only this from a GUI for active query.
Otherwise sessionRemove and sessionCopy will not have updated the list"""
r = nsmServerControl.exportSessionsAsDicts()
return [s["nsmSessionName"] for s in r]

def buildSystemPrograms():
"""Build a list of dicts with the .desktop files (or similar) of all NSM compatible programs
present on the system"""
programDatabase.build()
def getSystemPrograms():
"""Returns the cached database from buildProgramDatabase. No automatic update. Empty on program
start"""
return programDatabase.programs

def setSystemsPrograms(listOfDicts:list):
programDatabase.loadPrograms(listOfDicts)

def getNsmExecutables()->set:
"""Cached access fort fast membership tests. Is this program in the PATH?"""
return programDatabase.nsmExecutables

def getUnfilteredExecutables():
"""Return a list of unique names without paths or directories of all exectuables in users $PATH.
This is intended for a program starter prompt. GUI needs to supply tab completition or search
itself"""
return programDatabase.unfilteredExecutables


#Session Control
#No project running
#There is no callback for _sessionsChanged because we poll that in the event loop.

def sessionNew(newName:str, startClients:list=[]):
nsmServerControl.new(newName, startClients)

def sessionRename(nsmSessionName:str, newName:str):
"""only for non-open sessions"""
nsmServerControl.renameSession(nsmSessionName, newName)

def sessionCopy(nsmSessionName:str, newName:str):
"""Create a copy of the session. Removes the lockfile, if any.
Has some safeguards inside so it will not crash."""
nsmServerControl.copySession(nsmSessionName, newName)

def sessionOpen(nsmSessionName:str):
"""Saves the current session and loads a different existing session."""
nsmServerControl.open(nsmSessionName)

def sessionQuery(nsmSessionName:str):
"""For the occasional out-of-order information query.
Exports a single session project in the format of nsmServerControl.exportSessionsAsDicts"""
return nsmServerControl.sessionAsDict(nsmSessionName)

def sessionForceLiftLock(nsmSessionName:str):
nsmServerControl.forceLiftLock(nsmSessionName)
callbacks._sessionLocked(nsmSessionName, False)

def sessionDelete(nsmSessionName:str):
nsmServerControl.deleteSession(nsmSessionName)

#While Project is open
def sessionSave():
"""Saves the current session."""
nsmServerControl.save()

def sessionClose(blocking=False):
"""Saves and closes the current session."""
nsmServerControl.close(blocking)

def sessionAbort(blocking=False):
"""Close without saving the current session."""
nsmServerControl.abort(blocking)

def sessionSaveAs(nsmSessionName:str):
"""Duplicate in NSM terms. Make a copy, close the current one, open the new one.
However, it will NOT send the session clossed signal, just a session changed one."""
nsmServerControl.duplicate(nsmSessionName)

def setDescription(text:str):
nsmServerControl.setDescription(text)

#Client Handling
def clientAdd(executableName):
nsmServerControl.clientAdd(executableName)
#status hook triggers clientStatusChanged callback

def clientStop(clientId:str):
nsmServerControl.clientStop(clientId)

def clientResume(clientId:str):
"""Opposite of clientStop"""
nsmServerControl.clientResume(clientId)

def clientRemove(clientId:str):
"""Client must be already stopped! We will do that without further question.
Remove from the session. Will not delete the save-files, but make them inaccesible"""
nsmServerControl.clientRemove(clientId)

def clientSave(clientId:str):
"""Saves only the given client"""
nsmServerControl.clientSave(clientId)

def clientToggleVisible(clientId:str):
"""Works only if client announced itself with this feature"""
nsmServerControl.clientToggleVisible(clientId)

def clientHideAll():
nsmServerControl.allClientsHide()

def clientShowAll():
nsmServerControl.allClientsShow()

def clientNameOverride(clientId:str, name:str):
"""An argodejo-specific function that requires the client nsm-data in the session.
If nsm-data is not present this function will write nothing, not touch any data.
It will still send a callback to revert any GUI changes back to the original name.

We accept empty string as a name to remove the name override
"""
nsmServerControl.clientNameOverride(clientId, name)

def executableInSession(executable:str)->dict:
"""Returns None if no client with this executable is in the session,
else returns a dict with its export-data.
If multiple clients with this exe are in the session only one is returned, whatever Python
thinks is good"""
for clientId, dic in nsmServerControl.internalState["clients"].items():
if executable == dic["executable"]:
return dic
else:
return None

#Global Datastructures, set in startEngine
nsmServerControl = None
eventLoop = None
sessionWatcher = None
callbacks = Callbacks() #This needs to be defined before startEngine() so a GUI can register its callbacks. The UI will then startEngine and wait to reveice the initial round of callbacks

+ 45
- 0
engine/config.py View File

@@ -0,0 +1,45 @@
#! /usr/bin/env python3
# -*- coding: utf-8 -*-

#Do not change these during runtime!

METADATA={
#The pretty name of this program. Used for NSM display and Jack client name
#Can contain everything a linux file/path supports. Never change this or it will break the
#session, making your file unable to load and destroying saved Jack connections.
"name" : "Argodejo",

#Set this to the name the user types into a terminal.
#MUST be the same as the binary name as well as the name in configure.
#Program reports that as proc title so you can killall it by name.
#Should not contain spaces or special characters. We use this as save file extension as well
#to distinguish between compatible program versions. In basic programs this will just be e.g.
#patroneo. But in complex programs with a bright future it will be "laborejo1" "laborejo2" etc.
"shortName" : "argodejo",
"version" : "1.0",
"year" : "2020",
"author" : "Laborejo Software Suite",
"url" : "https://www.laborejo.org/argodejo",
"supportedLanguages" : {"German":"de.qm"},
#Show the About Dialog the first time the program starts up. This is the initial state for a
#new instance in NSM, not the saved state! Decide on how annoying it would be for every new
#instance to show about. Fluajho does not show it because you add it many times into a session.
#Patroneo does because its only added once.
"showAboutDialogFirstStart" : False,
"preferredClients" : {"data":"nsm-data", "connections":"jackpatch", "proxy":"nsm-proxy"},

#Various strings for the README
#Extra whitespace will be stripped so we don't need to worry about docstring indentation
"description" : """
Hello World

""" + "\n" + """
Foo Bar""",

"dependencies" : "\n".join("* "+dep for dep in ("A Brain", "Linux" )),

}

+ 230
- 0
engine/findprograms.py View File

@@ -0,0 +1,230 @@
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Copyright 2020, Nils Hilbricht, Germany ( https://www.hilbricht.net )

The Non-Session-Manager by Jonathan Moore Liles <male@tuxfamily.org>: http://non.tuxfamily.org/nsm/
With help from code fragments from https://github.com/attwad/python-osc ( DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE v2 )

API documentation: http://non.tuxfamily.org/nsm/API.html

This file is part of the Laborejo Software Suite ( https://www.laborejo.org ),
more specifically its template base application.

The Template Base Application is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
import logging; logger = logging.getLogger(__name__); logger.info("import")

import pathlib
import configparser
import subprocess
import os
import stat


class SupportedProgramsDatabase(object):
"""Find all binaries. Use all available resources: xdg desktop files, binary string seach in
executables, data bases, supplement with user choices.

We generate the same format as configParser does with .desktop files as _sections dict.

Example:
{ 'categories': 'AudioVideo;Audio;X-Recorders;X-Multitrack;X-Jack;',
'comment': 'Easy to use pattern sequencer for JACK and NSM',
'comment[de]': 'Einfach zu bedienender Pattern-Sequencer',
'exec': 'patroneo',
'genericname': 'Sequencer',
'icon': 'patroneo',
'name': 'Patroneo',
'startupnotify': 'false',
'terminal': 'false',
'type': 'Application',
'version': '1.4.1',
'x-nsm-capable': 'true'}

In case there is a file in PATH or database but has no .desktop we create our own entry with
missing data.
"""

def __init__(self):
self.blacklist = ("nsmd", "non-daw", "carla")
self.morePrograms = ("thisdoesnotexisttest", "carla-rack", "carla-patchbay", "carla-jack-multi", "ardour5", "ardour6", "nsm-data", "nsm-jack") #only programs not found by buildCache_grepExecutablePaths because they are just shellscripts and do not contain /nsm/server/announce.
self.knownDesktopFiles = { #shortcuts to the correct desktop files. Reverse lookup binary->desktop creates false entries, for example ZynAddSubFx and Carla.
"zynaddsubfx": "zynaddsubfx-jack.desktop", #value will later get replaced with the .desktop entry
"carla-jack-multi" : "carla.desktop",
}
self.programs = [] #list of dicts. guaranteed keys: argodejoExec, name, argodejoFullPath. And probably others, like description and version.
self.nsmExecutables = set() #set of executables for fast membership, if a GUI wants to know if they are available. Needs to be build "manually" with self.programs. no auto-property for a list. at least we don't want to do the work.
#.build needs to be called from the api/GUI.
self.unfilteredExecutables = self.buildCache_unfilteredExecutables() #This doesn't take too long. we can start that every time. It will get updated in build as well.
#self.build() #fills self.programs and

def buildCache_grepExecutablePaths(self):
"""return a list of executable names in the path
Grep explained:
-s silent. No errors, eventhough subprocess uses stdout only
-R recursive with symlinks. We don't want to look in subdirs because that is not allowed by
PATH and nsm, but we want to follow symlinks
"""
result = []
executablePaths = [pathlib.Path(p) for p in os.environ["PATH"].split(":")]
for path in executablePaths:
command = f"grep -iRsnl {path} -e /nsm/server/announce"
completedProcess = subprocess.run(command, capture_output=True, text=True, shell=True)
for fullPath in completedProcess.stdout.split():
exe = pathlib.Path(fullPath).relative_to(path)
if not str(exe) in self.blacklist:
result.append((str(exe), str(fullPath)))

for prg in self.morePrograms:
for path in executablePaths:
if pathlib.Path(path, prg).is_file():
result.append((str(prg), str(pathlib.Path(path, prg))))
break #inner loop
return result

def buildCache_DesktopEntries(self):
"""Go through all dirs including subdirs"""
xdgPaths = (
pathlib.Path("/usr/share/applications"),
pathlib.Path("/usr/local/share/applications"),
pathlib.Path(pathlib.Path.home(), ".local/share/applications"),
)

config = configparser.ConfigParser()
allDesktopEntries = []
for basePath in xdgPaths:
for f in basePath.glob('**/*'):
if f.is_file() and f.suffix == ".desktop":
config.clear()
config.read(f)
entryDict = dict(config._sections["Desktop Entry"])
if f.name == "zynaddsubfx-jack.desktop":
self.knownDesktopFiles["zynaddsubfx"] = entryDict
elif f.name == "carla.desktop":
self.knownDesktopFiles["carla-jack-multi"] = entryDict
#in any case:
allDesktopEntries.append(entryDict) #_sections 'DesktopEntry':{dictOfActualData)
return allDesktopEntries

def loadPrograms(self, listOfDicts):
"""Qt Settings will send us this"""
self.programs = listOfDicts
self.nsmExecutables = set(d["argodejoExec"] for d in self.programs)

def build(self):
"""Can be called at any time by the user to update after installing new programs"""
logger.info("Building launcher database. This might take a minute")
self.programs = self._build()
self.unfilteredExecutables = self.buildCache_unfilteredExecutables()
self.nsmExecutables = set(d["argodejoExec"] for d in self.programs)
self._buildWhitelist()
logger.info("Building launcher database done.")

def _exeToDesktopEntry(self, exe:str)->dict:
"""Assumes self.desktopEntries is up to date
Convert one exe (not full path!) to one dict entry. """
if exe in self.knownDesktopFiles: #Shortcut through internal database
entry = self.knownDesktopFiles[exe]
else: #Reverse Search desktop files.
for entry in self.desktopEntries:
if "exec" in entry and exe.lower() in entry["exec"].lower():
return entry
#else: #Foor loop ended. Did not find any matching desktop file

return None

def _build(self):
self.executables = self.buildCache_grepExecutablePaths()
self.desktopEntries = self.buildCache_DesktopEntries()

leftovers = set(self.executables)
matches = [] #list of dicts
for exe, fullPath in self.executables:
entry = self._exeToDesktopEntry(exe)
if entry: #Found match!
entry["argodejoFullPath"] = fullPath
#We don't want .desktop syntax like "qmidiarp %F"
entry["argodejoExec"] = exe
matches.append(entry)
try:
leftovers.remove((exe,fullPath))
except KeyError:
pass #Double entries like zyn-jack zyn-alsa etc.
"""
if exe in self.knownDesktopFiles: #Shortcut through internal database
entry = self.knownDesktopFiles[exe]
else: #Reverse Search desktop files.
for entry in self.desktopEntries:
if "exec" in entry and exe.lower() in entry["exec"].lower():
break #found entry. break inner loop to keep it
else: #Foor loop ended. Did not find any matching desktop file
#If we omit continue it will just write exe and fullPath in any desktop file.
continue

#Found match!
entry["argodejoFullPath"] = fullPath
#We don't want .desktop syntax like "qmidiarp %F"
entry["argodejoExec"] = exe
matches.append(entry)
try:
leftovers.remove((exe,fullPath))
except KeyError:
pass #Double entries like zyn-jack zyn-alsa etc.
"""
for exe,fullPath in leftovers:
pseudoEntry = {"name": exe.title(), "argodejoExec":exe, "argodejoFullPath":fullPath}
matches.append(pseudoEntry)
return matches
def buildCache_unfilteredExecutables(self):
def isexe(path):
"""executable by owner"""
return path.is_file() and stat.S_IXUSR & os.stat(path)[stat.ST_MODE] == 64
result = []
executablePaths = [pathlib.Path(p) for p in os.environ["PATH"].split(":")]
for path in executablePaths:
result += [str(pathlib.Path(f).relative_to(path)) for f in path.glob("*") if isexe(f)]
return sorted(list(set(result)))

def _buildWhitelist(self):
"""For reliable, fast and easy selection this is the whitelist.
It will be populated from a template-list of well-working clients and then all binaries not
in the path are filtered out. This can be presented to the user without worries."""
#Assumes to be called only from self.build
startexecutables = set(("doesnotexist", "laborejo2", "patroneo", "vico", "fluajho", "carla-rack", "carla-patchbay", "carla-jack-multi", "ardour6", "drumkv1_jack", "synthv1_jack", "padthv1_jack", "samplv1_jack", "zynaddsubfx", "ADLplug", "OPNplug", "non-mixer", "non-sequencer", "non-timeline"))
for prog in self.programs:
prog["whitelist"] = prog["argodejoExec"] in startexecutables

"""
matches = []
for exe in startexecutables:
entry = self._exeToDesktopEntry(exe)
if entry: #Found match!
#We don't want .desktop syntax like "qmidiarp %F"
entry["argodejoExec"] = exe
matches.append(entry)
return matches
"""

programDatabase = SupportedProgramsDatabase()

+ 1603
- 0
engine/nsmservercontrol.py
File diff suppressed because it is too large
View File


+ 33
- 0
engine/old View File

@@ -0,0 +1,33 @@
def projectAsDict(self, nsmName:str)->dict:
entry = {}
entry["nsmName"] = nsmName
entry["name"] = os.path.basename(nsmName)
basePath = pathlib.Path(PATHS["sessionRoot"], nsmName)
sessionFile = pathlib.Path(basePath, "session.nsm")

if not sessionFile.exists():
logging.info("Got wrong session directory from nsmd. Race condition after delete? Project: " + repr(sessionFile))
return None

timestamp = datetime.fromtimestamp(sessionFile.stat().st_mtime).isoformat(sep=" ", timespec='minutes')
entry["lastSavedDate"] = timestamp
entry["sessionFile"] = sessionFile
entry["lockFile"] = pathlib.Path(basePath, ".lock")
entry["fullPath"] = str(basePath)
entry["sizeInBytes"] = sum(f.stat().st_size for f in basePath.glob('**/*') if f.is_file() )
entry["numberOfClients"] = len(open(sessionFile).readlines())
entry["hasSymlinks"] = self._checkDirectoryForSymlinks(basePath)
entry["parents"] = basePath.relative_to(PATHS["sessionRoot"]).parts[:-1] #tuple of each dir between NSM root and nsmName/session.nsm, exluding the actual project name. This is the tree
entry["locked"] = self._checkIfLocked(nsmName) #not for direct display
return entry

def exportProjects(self)->list:
"""Return a list of dicts of projects with additional information:
"""
results = []
data = self._requestProjects() #False for auto-sent data by nsmd
for nsmName in data:
result = self.projectAsDict(nsmName)
results.append(result)
return results


+ 220
- 0
engine/start.py View File

@@ -0,0 +1,220 @@
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Copyright 2020, Nils Hilbricht, Germany ( https://www.hilbricht.net )

This file is part of the Laborejo Software Suite ( https://www.laborejo.org ),
more specifically its template base application.

The Template Base Application is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""

#This is the first file in the program to be actually executed, after the executable which uses this as first instruction.

"""
We use a 'wrong' scheme of importing modules here because there are multiple exit conditions, good and bad.
We don't want to use all the libraries, including the big Qt one, only to end up displaying the --version and exit.
Same with the tests if jack or nsm are running.
"""

from engine.config import * #includes METADATA only. No other environmental setup is executed.
from qtgui.helper import setPaletteAndFont #our error boxes shall look like the rest of the program

"""
Check parameters first. It is possible that we will just --help or --version and exit. In this case
nothing gets loaded.
"""
import os.path
import argparse
parser = argparse.ArgumentParser(description=f"""{METADATA["name"]} - Version {METADATA["version"]} - Copyright {METADATA["year"]} by {METADATA["author"]} - {METADATA["url"]}""")
parser.add_argument("-v", "--version", action='version', version="{} {}".format(METADATA["name"], METADATA["version"]))
parser.add_argument("-V", "--verbose", action='store_true', help="(Development) Switch the logger to INFO and give out all kinds of information to get a high-level idea of what the program is doing.")

parser.add_argument("-u", "--url", action='store', dest="url", help="Force URL for the session. If there is already a running session we will connect to it. Otherwise we will start one there. Default is local host with random port. Example: osc.udp://myhost.localdomain:14294/")
parser.add_argument("--nsm-url", action='store', dest="url", help="Same as --url.")
parser.add_argument("-s", "--session", action='store', dest="session", help="Session to open on startup.")
parser.add_argument("--session-root", action='store', dest="sessionRoot", help="Root directory of all sessions. Defaults to '$HOME/NSM Sessions'")

args = parser.parse_args()


import logging
if args.verbose:
logging.basicConfig(level=logging.INFO) #development
#logging.getLogger().setLevel(logging.INFO) #development
else:
logging.basicConfig(level=logging.ERROR) #production
#logging.getLogger().setLevel(logging.ERROR) #production

logger = logging.getLogger(__name__)
logger.info("import")


"""set up python search path before the program starts and cbox gets imported.
We need to be earliest, so let's put it here.
This is influence during compiling by creating a temporary file "compiledprefix.py".
Nuitka complies that in, when make is finished we delete it.

#Default mode is a self-contained directory relative to the uncompiled patroneo python start script
"""

import sys
import os
import os.path
try:
from compiledprefix import prefix
compiledVersion = True
logger.info("Compiled prefix found: {}".format(prefix))
except ModuleNotFoundError as e:
compiledVersion = False

logger.info("Compiled version: {}".format(compiledVersion))

cboxSharedObjectVersionedName = "lib"+METADATA["shortName"]+".so." + METADATA["version"]

if compiledVersion:
PATHS={ #this gets imported
"root": "",
"bin": os.path.join(prefix, "bin"),
"doc": os.path.join(prefix, "share", "doc", METADATA["shortName"]),
"desktopfile": os.path.join(prefix, "share", "applications", METADATA["shortName"] + ".desktop"), #not ~/Desktop but our desktop file
"share": os.path.join(prefix, "share", METADATA["shortName"]),
"templateShare": os.path.join(prefix, "share", METADATA["shortName"], "template"),
"sessionRoot": args.sessionRoot,
"url": args.url,
"startupSession": args.session,
#"lib": os.path.join(prefix, "lib", METADATA["shortName"]), #cbox is found via the PYTHONPATH
}
cboxSharedObjectPath = os.path.join(prefix, "lib", METADATA["shortName"], cboxSharedObjectVersionedName)
_root = os.path.dirname(__file__)
_root = os.path.abspath(os.path.join(_root, ".."))
fallback_cboxSharedObjectPath = os.path.join(_root, "site-packages", cboxSharedObjectVersionedName)
#Local version has higher priority
if os.path.exists(fallback_cboxSharedObjectPath): #we are not yet installed, look in the source site-packages dir
os.environ["CALFBOXLIBABSPATH"] = fallback_cboxSharedObjectPath
elif os.path.exists(cboxSharedObjectPath): #we are installed
os.environ["CALFBOXLIBABSPATH"] = cboxSharedObjectPath
else:
pass
#no support for system-wide cbox in compiled mode. Error handling at the bottom of the file
else:
_root = os.path.dirname(__file__)
_root = os.path.abspath(os.path.join(_root, ".."))
PATHS={ #this gets imported
"root": _root,
"bin": _root,
"doc": os.path.join(_root, "documentation", "out"),
"desktopfile": os.path.join(_root, "desktop", "desktop.desktop"), #not ~/Desktop but our desktop file
"share": os.path.join(_root, "engine", "resources"),
"templateShare": os.path.join(_root, "template", "engine", "resources"),
"sessionRoot": args.sessionRoot,
"url": args.url,
"startupSession": args.session,
#"lib": "", #use only system paths
}
if os.path.exists (os.path.join(_root, "site-packages", cboxSharedObjectVersionedName)):
os.environ["CALFBOXLIBABSPATH"] = os.path.join(_root, "site-packages", cboxSharedObjectVersionedName)
#else use system-wide.
if os.path.exists (os.path.join(_root, "site-packages", "calfbox", "cbox.py")):
#add to the front to have higher priority than system site-packages
logger.info("Will attempt to start with local calfbox python module: {}".format(os.path.join(_root, "site-packages", "calfbox", "cbox.py")))
sys.path.insert(0, os.path.join(os.path.join(_root, "site-packages")))
#else try to use system-wide calfbox. Check for this and if the .so exists at the end of this file.


logger.info("PATHS: {}".format(PATHS))


def exitWithMessage(message:str):
title = f"""{METADATA["name"]} Error"""
if sys.stdout.isatty():
sys.exit(title + ": " + message)
else:
from PyQt5.QtWidgets import QMessageBox, QApplication
#This is the start file for the Qt client so we know at least that Qt is installed and use that for a warning.
qErrorApp = QApplication(sys.argv)
setPaletteAndFont(qErrorApp)
QMessageBox.critical(qErrorApp.desktop(), title, message)
qErrorApp.quit()
sys.exit(title + ": " + message)

def setProcessName(executableName):
"""From
https://stackoverflow.com/questions/31132342/change-process-name-while-executing-a-python-script
"""
import ctypes
lib = ctypes.cdll.LoadLibrary(None)
prctl = lib.prctl
prctl.restype = ctypes.c_int
prctl.argtypes = [ctypes.c_int, ctypes.c_char_p, ctypes.c_ulong,
ctypes.c_ulong, ctypes.c_ulong]
def set_proctitle(new_title):
result = prctl(15, new_title, 0, 0, 0)
if result != 0:
raise OSError("prctl result: %d" % result)
set_proctitle(executableName.encode())

def _is_jack_running():
"""Check for JACK"""
import ctypes
import os
silent = os.open(os.devnull, os.O_WRONLY)
stdout = os.dup(1)
stderr = os.dup(2)
os.dup2(silent, 1) #stdout
os.dup2(silent, 2) #stderr
cjack = ctypes.cdll.LoadLibrary("libjack.so.0")
class jack_client_t(ctypes.Structure):
_fields_ = []
cjack.jack_client_open.argtypes = [ctypes.c_char_p, ctypes.c_int, ctypes.POINTER(ctypes.c_int)] #the two ints are enum and pointer to enum. #http://jackaudio.org/files/docs/html/group__ClientFunctions.html#gab8b16ee616207532d0585d04a0bd1d60
cjack.jack_client_open.restype = ctypes.POINTER(jack_client_t)
ctypesJackClient = cjack.jack_client_open("probe".encode("ascii"), 0x01, None) #0x01 is the bit set for do not autostart JackNoStartServer
try:
ret = bool(ctypesJackClient.contents)
except ValueError: #NULL pointer access
ret = False
cjack.jack_client_close(ctypesJackClient)
os.dup2(stdout, 1) #stdout
os.dup2(stderr, 2) #stderr
return ret

def checkJackOrExit(prettyName):
import sys
if not _is_jack_running():
exitWithMessage("JACK Audio Connection Kit is not running. Please start it.")


checkJackOrExit(METADATA["name"])
setProcessName(METADATA["shortName"])


#Catch Exceptions even if PyQt crashes.
import sys
sys._excepthook = sys.excepthook
def exception_hook(exctype, value, traceback):
"""This hook purely exists to call sys.exit(1) even on a Qt crash
so that atexit gets triggered"""
#print(exctype, value, traceback)
logger.error("Caught crash in execpthook. Trying too execute atexit anyway")
sys._excepthook(exctype, value, traceback)
sys.exit(1)
sys.excepthook = exception_hook

+ 154
- 0
engine/watcher.py View File

@@ -0,0 +1,154 @@
#! /usr/bi n/env python3
# -*- coding: utf-8 -*-
"""
Copyright 2019, Nils Hilbricht, Germany ( https://www.hilbricht.net )

This file is part of the Laborejo Software Suite ( https://www.laborejo.org ),
more specifically its template base application.

The Template Base Application is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""

import logging; logger = logging.getLogger(__name__); logger.info("import")

#Standard Library
from datetime import datetime
import pathlib
import os
#Our Modules
from engine.start import PATHS

def fast_scandir(dir):
"""
Get all subdirectories recursively.
https://stackoverflow.com/questions/973473/getting-a-list-of-all-subdirectories-in-the-current-directory"""
subfolders= [f.path for f in os.scandir(dir) if f.is_dir()]
for dir in list(subfolders):
subfolders.extend(fast_scandir(dir))
return subfolders


class Watcher(object):
"""
Initialize with the server controller

The watcher will should only run when the program is in the mode to choose a session.
If a session is loaded it will technically work, but will be a waste of resources.

The watcher will also trigger the nsmController to redundantly query for a session list,
for example when a new empty sessions gets created or duplicated. Once because nsmd sends the
"new" signal, and then our watcher will notice the change itself. However, this happens only so
often and can be accepted, so the program does not need more checks and exceptions.

Inform you via callback when:

a) a session dir was deleted
b) a new directory got created.
c) session directory renamed or moved
d) session.nsm changed timestamp
e) A lockfile appeared or disappeared

We cannot poll nsmServerControl.exportSessionsAsDicts() because that triggers an nsmd response
including log message and will flood their console. Instead this class only offers incremental
updates.
Another way is to watch the dir for changes ourselves in in some cases request a new project
list from nsmd.

Lockfile functionality goes beyond what NSM offers. A session-daemon can open only one
project at a time. If you try to open another project with a second GUI (but same NSM-URL)
it goes wrong a bit, at least in the non-session-manager GUI. They will leave a zombie lockfile.
However, it still is possible to open a second nsmd instance. In this case the lockfile prevents
opening a session twice. And we are reflecting the opened state of the project, no matter from
which daemon. Horray for us :)

Clients can only be added or removed while a session is locked. We do not check nor update
number of clients or symlinks. Therefore we advice a GUI to deactivate the display of
these two values while a session is locked (together with size)
"""

def __init__(self, nsmServerControl):
self.active = True
self._nsmServerControl = nsmServerControl
assert self._nsmServerControl.sessionRoot
self._directories = fast_scandir(self._nsmServerControl.sessionRoot)

logger.info("Requestion our own copy of the session list. Don't worry about the apparent redundant call :)")
self._lastExport = self._nsmServerControl.exportSessionsAsDicts()
self._lastTimestamp = {d["nsmSessionName"]:d["lastSavedDate"] for d in self._lastExport} #str:str
#Init all values with None will send the initial state via callback on program start, which is what the user wants to know.
self._lastLockfile = {d["nsmSessionName"]:None for d in self._lastExport} #str:bool

self.timeStampHook = None # a single function that gets informed of changes, most likely the api callback
self.lockFileHook = None # a single function that gets informed of changes, most likely the api callback
self.sessionsChangedHook = None # the api callback function api.callbacks._sessionsChanged. Rarely used.

def resume(self, *args):
"""For api callbacks"""
self.active = True
#If we returned from an open session that will surely have changed. Trigger a single poll
self.process()
logger.info("Watcher resumed")
def suspend(self, *args):
"""For api callbacks"""
self.active = False
logger.info("Watcher suspended")

def process(self):
"""Add this to your event loop.
We look for any changes in the directory structure.
If we detect any we simply trigger a new NSM export and a new NSM generated project
list via callback. We do not expect this to happen often.

This will also trigger if we add a new session ourselves. This *is* our way to react to
new Sessions.
"""
if not self.active:
return
if self.sessionsChangedHook:
current_directories = fast_scandir(self._nsmServerControl.sessionRoot)
if not self._directories == current_directories:
self._directories = current_directories
self._lastExport = self.sessionsChangedHook() #will gather its own data, send it to api callbacks, but also return for us.
self._lastTimestamp = {d["nsmSessionName"]:d["lastSavedDate"] for d in self._lastExport} #str:str
self._lastLockfile = {d["nsmSessionName"]:None for d in self._lastExport} #str:bool

#Now check the incremental hooks.
#No hooks, no reason to process
if not (self.timeStampHook or self.lockFileHook):
logger.info("No watcher-hooks to process")
return

for entry in self._lastExport:
nsmSessionName = entry["nsmSessionName"]

#Timestamp of session.nsm
if self.timeStampHook:
timestamp = datetime.fromtimestamp(entry["sessionFile"].stat().st_mtime).isoformat(sep=" ", timespec='minutes') #same format as server control export
if not timestamp == self._lastTimestamp[nsmSessionName]: #This will only trigger on a minute-based slot, which is all we want and need. This is for relaying information to the user, not for advanced processing.
self._lastTimestamp[nsmSessionName] = timestamp
self.timeStampHook(nsmSessionName, timestamp)

#Lockfiles
if self.lockFileHook:
lockfileState = entry["lockFile"].is_file()
if not self._lastLockfile[nsmSessionName] == lockfileState:
self._lastLockfile[nsmSessionName] = lockfileState
self.lockFileHook(nsmSessionName, lockfileState)

BIN
icon.png View File

Before After
Width: 64  |  Height: 64  |  Size: 1.7KB

+ 110
- 0
qtgui/addclientprompt.py View File

@@ -0,0 +1,110 @@
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Copyright 2020, Nils Hilbricht, Germany ( https://www.hilbricht.net )

This file is part of the Laborejo Software Suite ( https://www.laborejo.org ),
more specifically its template base application.

The Template Base Application is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""

import logging; logger = logging.getLogger(__name__); logger.info("import")

#Standard Library

#Engine
import engine.api as api

#Third Party
from PyQt5 import QtCore, QtWidgets

class PromptWidget(QtWidgets.QDialog):

wordlist = None
minlen = None

def __init__(self, parent):
super().__init__(parent)
layout = QtWidgets.QFormLayout()
#layout = QtWidgets.QVBoxLayout()
self.setLayout(layout)
self.setWindowFlag(QtCore.Qt.Popup, True)

self.comboBox = QtWidgets.QComboBox(self)
self.comboBox.setEditable(True)

if PromptWidget.wordlist:
completer = QtWidgets.QCompleter(PromptWidget.wordlist)
completer.setModelSorting(QtWidgets.QCompleter.CaseInsensitivelySortedModel)
completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
completer.setCompletionMode(QtWidgets.QCompleter.PopupCompletion)
completer.activated.connect(self.process) #To avoid double-press enter to select one we hook into the activated signal and trigger process
self.comboBox.setCompleter(completer)
self.comboBox.setMinimumContentsLength(PromptWidget.minlen)
labelString = QtCore.QCoreApplication.translate("PromptWidget", "Type in the name of an executable file on your system.")
else:
labelString = QtCore.QCoreApplication.translate("PromptWidget", "No program database found. Please update through Control menu.")
label = QtWidgets.QLabel(labelString)
layout.addWidget(label)
self.comboBox.setSizeAdjustPolicy(QtWidgets.QComboBox.AdjustToMinimumContentsLength)
layout.addWidget(self.comboBox)

errorString = QtCore.QCoreApplication.translate("PromptWidget", "Command not accepted!<br>Parameters, --switches and relative paths are not allowed.<br>Use nsm-proxy or write a starter-script instead.")
errorString = "<i>" + errorString + "</i>"
self.errorLabel = QtWidgets.QLabel(errorString)
layout.addWidget(self.errorLabel)
self.errorLabel.hide() #shown in process

buttonBox = QtWidgets.QDialogButtonBox(QtWidgets.QDialogButtonBox.Ok | QtWidgets.QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.process)
buttonBox.rejected.connect(self.reject)
layout.addWidget(buttonBox)
self.exec() #blocks until the dialog gets closed



def abortHandler(self):
pass

def process(self):
"""Careful! Calling this eats python errors without notice.
Make sure your objects exists and your syntax is correct"""
assert PromptWidget.wordlist
assert PromptWidget.minlen
curText = self.comboBox.currentText()
if curText in PromptWidget.wordlist:
api.clientAdd(curText)
logger.info(f"Prompt accepted {curText} and will send it to clientAdd")
self.done(True)
else:
logger.info(f"Prompt did not accept {curText}.Showing info to the user.")
self.errorLabel.show()
def updateWordlist():
"""in case programs are installed while the session is running the user can
manually call a database update"""
PromptWidget.wordlist = api.getUnfilteredExecutables()
if PromptWidget.wordlist:
PromptWidget.minlen = len(max(PromptWidget.wordlist, key=len))
else:
logger.error("Executable list came back empty! Most likely an error in application database build. Not trivial!")
def askForExecutable(parent):
PromptWidget(parent)

+ 99
- 0
qtgui/descriptiontextwidget.py View File

@@ -0,0 +1,99 @@
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Copyright 2020, Nils Hilbricht, Germany ( https://www.hilbricht.net )

This file is part of the Laborejo Software Suite ( https://www.laborejo.org )

The Template Base Application is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""

import logging; logger = logging.getLogger(__name__); logger.info("import")

#Standard Library

#Engine
import engine.api as api


#Third Party
from PyQt5 import QtCore, QtGui, QtWidgets


class DescriptionController(object):
"""Not a subclass. Controls a TextEditWidget to hold the session-description from nsm-data.
Can be used on multiple text widgets. One controller for one textwidget."""

def __init__(self, mainWindow, parentGroupBox:QtWidgets.QGroupBox, plainTextWidget:QtWidgets.QPlainTextEdit):
self.mainWindow = mainWindow
self.description = plainTextWidget
self.parentGroupBox = parentGroupBox

self.placeHolderDescription = QtCore.QCoreApplication.translate("LoadedSessionDescription", "Double click to add the client nsm-data to write here.\nUse it for notes, TODO, references etc…")
#We do NOT use the Qt placeholder text because that shows even when editing is possible. Our visual feedback is changing from placeholder to empty.
self.description.setEnabled(False)
self._reactCallback_dataClientDescriptionChanged(None) #set up description
self.parentGroupBox.mouseDoubleClickEvent = self._doubleClickToResumeOrAddNsmData
self.description.textChanged.connect(self.sendDescriptionToApi) #TODO: this is every keystroke, but it is impossible to solve a multi-GUI network system where a save signal comes from outside.. we need update every char. Maybe a genius in the future will solve this.
#self.description.focusOutEvent = self._descriptionFocusOut
api.callbacks.dataClientDescriptionChanged.append(self._reactCallback_dataClientDescriptionChanged) #Session description

def sendDescriptionToApi(self):
"""We cannot send every keystroke over the OSC-network. Therefore we wait:
This is called by several events that "feel" like editing is done now:
Focus out, Ctlr+S, Alt+S."""
api.setDescription(self.description.toPlainText()) #this is not save yet. Just forward to data client.

#def _descriptionFocusOut(self, event):
# self.sendDescriptionToApi()
# QtWidgets.QPlainTextEdit.focusOutEvent(self.description, event)

def _reactCallback_dataClientDescriptionChanged(self, desc:str):
"""Put the session description into our text field.
We send each change, so we receive this signal each detail change.

The cursor changes in between so we force the position.
"""
self.description.blockSignals(True)
if not desc is None: #may be None for closing session
oldPos = self.description.textCursor().position()
self.description.setPlainText(desc) #plain textedit
self.description.setEnabled(True)
c = self.description.textCursor()
c.setPosition(oldPos)
self.description.setTextCursor(c)
else:
self.description.setEnabled(False)
self.description.setPlainText(self.placeHolderDescription)
self.description.blockSignals(False)

def _doubleClickToResumeOrAddNsmData(self, event):
"""Intended for doubleClickEvent, so we get an event.
Do nothing when nsm-data is present. Add it when it was never there.
Resume it if stopped in the session.

When QPlainTextEdit is disabled it will forward doubleClick to the parent widget,
which is this function. If enabled the groupBox description and frame will be clickable, we
do nothing in this case.
"""
if self.description.isEnabled():
pass
else:
d = api.executableInSession("nsm-data")
if d:
api.clientResume(d["clientId"])
else:
api.clientAdd("nsm-data")
QtWidgets.QGroupBox.mouseDoubleClickEvent(self.parentGroupBox, event)

+ 356
- 0
qtgui/designer/mainwindow.py View File

@@ -0,0 +1,356 @@
# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'mainwindow.ui'
#
# Created by: PyQt5 UI code generator 5.14.1
#
# WARNING! All changes made in this file will be lost!


from PyQt5 import QtCore, QtGui, QtWidgets


class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(953, 763)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.verticalLayout = QtWidgets.QVBoxLayout(self.centralwidget)
self.verticalLayout.setObjectName("verticalLayout")
self.tabbyCat = QtWidgets.QTabWidget(self.centralwidget)
self.tabbyCat.setObjectName("tabbyCat")
self.tab_quick = QtWidgets.QWidget()
self.tab_quick.setObjectName("tab_quick")
self.horizontalLayout_2 = QtWidgets.QHBoxLayout(self.tab_quick)
self.horizontalLayout_2.setObjectName("horizontalLayout_2")
self.quickStackedWidget = QtWidgets.QStackedWidget(self.tab_quick)
self.quickStackedWidget.setObjectName("quickStackedWidget")
self.page_quickSessionChooser = QtWidgets.QWidget()
self.page_quickSessionChooser.setObjectName("page_quickSessionChooser")
self.verticalLayout_9 = QtWidgets.QVBoxLayout(self.page_quickSessionChooser)
self.verticalLayout_9.setObjectName("verticalLayout_9")
self.quickNewSession = QtWidgets.QPushButton(self.page_quickSessionChooser)
self.quickNewSession.setAutoDefault(True)
self.quickNewSession.setDefault(True)
self.quickNewSession.setObjectName("quickNewSession")
self.verticalLayout_9.addWidget(self.quickNewSession)
self.scrollArea = QtWidgets.QScrollArea(self.page_quickSessionChooser)
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setObjectName("scrollArea")
self.quickSessionChooser = QtWidgets.QWidget()
self.quickSessionChooser.setGeometry(QtCore.QRect(0, 0, 98, 28))
self.quickSessionChooser.setObjectName("quickSessionChooser")
self.verticalLayout_7 = QtWidgets.QVBoxLayout(self.quickSessionChooser)
self.verticalLayout_7.setObjectName("verticalLayout_7")
spacerItem = QtWidgets.QSpacerItem(20, 586, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.verticalLayout_7.addItem(spacerItem)
self.scrollArea.setWidget(self.quickSessionChooser)
self.verticalLayout_9.addWidget(self.scrollArea)
self.quickStackedWidget.addWidget(self.page_quickSessionChooser)
self.page_quickSessionLoaded = QtWidgets.QWidget()
self.page_quickSessionLoaded.setObjectName("page_quickSessionLoaded")
self.verticalLayout_8 = QtWidgets.QVBoxLayout(self.page_quickSessionLoaded)
self.verticalLayout_8.setContentsMargins(0, 0, 0, 0)
self.verticalLayout_8.setSpacing(0)
self.verticalLayout_8.setObjectName("verticalLayout_8")
self.quickSessionNameLineEdit = QtWidgets.QLineEdit(self.page_quickSessionLoaded)
self.quickSessionNameLineEdit.setAlignment(QtCore.Qt.AlignCenter)
self.quickSessionNameLineEdit.setObjectName("quickSessionNameLineEdit")
self.verticalLayout_8.addWidget(self.quickSessionNameLineEdit)
self.widget_2 = QtWidgets.QWidget(self.page_quickSessionLoaded)
self.widget_2.setObjectName("widget_2")
self.horizontalLayout_4 = QtWidgets.QHBoxLayout(self.widget_2)
self.horizontalLayout_4.setContentsMargins(0, -1, 0, -1)
self.horizontalLayout_4.setObjectName("horizontalLayout_4")
self.quickSaveOpenSession = QtWidgets.QPushButton(self.widget_2)
self.quickSaveOpenSession.setObjectName("quickSaveOpenSession")
self.horizontalLayout_4.addWidget(self.quickSaveOpenSession)
self.quickCloseOpenSession = QtWidgets.QPushButton(self.widget_2)
self.quickCloseOpenSession.setObjectName("quickCloseOpenSession")
self.horizontalLayout_4.addWidget(self.quickCloseOpenSession)
self.verticalLayout_8.addWidget(self.widget_2)
self.splitter = QtWidgets.QSplitter(self.page_quickSessionLoaded)
self.splitter.setOrientation(QtCore.Qt.Vertical)
self.splitter.setObjectName("splitter")
self.quickSessionNotesGroupBox = QtWidgets.QGroupBox(self.splitter)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(1)
sizePolicy.setHeightForWidth(self.quickSessionNotesGroupBox.sizePolicy().hasHeightForWidth())
self.quickSessionNotesGroupBox.setSizePolicy(sizePolicy)
self.quickSessionNotesGroupBox.setObjectName("quickSessionNotesGroupBox")
self.verticalLayout_10 = QtWidgets.QVBoxLayout(self.quickSessionNotesGroupBox)
self.verticalLayout_10.setContentsMargins(0, 0, 0, 0)
self.verticalLayout_10.setSpacing(0)
self.verticalLayout_10.setObjectName("verticalLayout_10")
self.quickSessionNotesPlainTextEdit = QtWidgets.QPlainTextEdit(self.quickSessionNotesGroupBox)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.quickSessionNotesPlainTextEdit.sizePolicy().hasHeightForWidth())
self.quickSessionNotesPlainTextEdit.setSizePolicy(sizePolicy)
self.quickSessionNotesPlainTextEdit.setObjectName("quickSessionNotesPlainTextEdit")
self.verticalLayout_10.addWidget(self.quickSessionNotesPlainTextEdit)
self.quickSessionClientsListWidget = QtWidgets.QListWidget(self.splitter)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(6)
sizePolicy.setHeightForWidth(self.quickSessionClientsListWidget.sizePolicy().hasHeightForWidth())
self.quickSessionClientsListWidget.setSizePolicy(sizePolicy)
self.quickSessionClientsListWidget.setViewMode(QtWidgets.QListView.IconMode)
self.quickSessionClientsListWidget.setObjectName("quickSessionClientsListWidget")
self.verticalLayout_8.addWidget(self.splitter)
self.quickStackedWidget.addWidget(self.page_quickSessionLoaded)
self.horizontalLayout_2.addWidget(self.quickStackedWidget)
self.tabbyCat.addTab(self.tab_quick, "")
self.tab_detailed = QtWidgets.QWidget()
self.tab_detailed.setObjectName("tab_detailed")
self.horizontalLayout = QtWidgets.QHBoxLayout(self.tab_detailed)
self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
self.horizontalLayout.setSpacing(0)
self.horizontalLayout.setObjectName("horizontalLayout")
self.detailedStackedWidget = QtWidgets.QStackedWidget(self.tab_detailed)
self.detailedStackedWidget.setObjectName("detailedStackedWidget")
self.stack_no_session = QtWidgets.QWidget()
self.stack_no_session.setObjectName("stack_no_session")
self.l_2 = QtWidgets.QHBoxLayout(self.stack_no_session)
self.l_2.setContentsMargins(9, 9, 9, 9)
self.l_2.setSpacing(6)
self.l_2.setObjectName("l_2")
self.widget = QtWidgets.QWidget(self.stack_no_session)
self.widget.setObjectName("widget")
self.verticalLayout_3 = QtWidgets.QVBoxLayout(self.widget)
self.verticalLayout_3.setObjectName("verticalLayout_3")
self.button_new_session = QtWidgets.QPushButton(self.widget)
self.button_new_session.setObjectName("button_new_session")
self.verticalLayout_3.addWidget(self.button_new_session)
self.button_load_selected_session = QtWidgets.QPushButton(self.widget)
self.button_load_selected_session.setObjectName("button_load_selected_session")
self.verticalLayout_3.addWidget(self.button_load_selected_session)
self.checkBoxNested = QtWidgets.QCheckBox(self.widget)
self.checkBoxNested.setChecked(True)
self.checkBoxNested.setObjectName("checkBoxNested")
self.verticalLayout_3.addWidget(self.checkBoxNested)
spacerItem1 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.verticalLayout_3.addItem(spacerItem1)
self.l_2.addWidget(self.widget)
self.session_tree = QtWidgets.QTreeWidget(self.stack_no_session)
self.session_tree.setObjectName("session_tree")
self.session_tree.headerItem().setText(0, "1")
self.l_2.addWidget(self.session_tree)
self.detailedStackedWidget.addWidget(self.stack_no_session)
self.stack_loaded_session = QtWidgets.QWidget()
self.stack_loaded_session.setObjectName("stack_loaded_session")
self.verticalLayout_4 = QtWidgets.QVBoxLayout(self.stack_loaded_session)
self.verticalLayout_4.setContentsMargins(9, 9, 9, 9)
self.verticalLayout_4.setSpacing(0)
self.verticalLayout_4.setObjectName("verticalLayout_4")
self.vSplitterProgramsLog = QtWidgets.QSplitter(self.stack_loaded_session)
self.vSplitterProgramsLog.setOrientation(QtCore.Qt.Vertical)
self.vSplitterProgramsLog.setObjectName("vSplitterProgramsLog")
self.hSplitterLauncherClients = QtWidgets.QSplitter(self.vSplitterProgramsLog)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(7)
sizePolicy.setHeightForWidth(self.hSplitterLauncherClients.sizePolicy().hasHeightForWidth())
self.hSplitterLauncherClients.setSizePolicy(sizePolicy)
self.hSplitterLauncherClients.setOrientation(QtCore.Qt.Horizontal)
self.hSplitterLauncherClients.setChildrenCollapsible(False)
self.hSplitterLauncherClients.setObjectName("hSplitterLauncherClients")
self.session_programs = QtWidgets.QGroupBox(self.hSplitterLauncherClients)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(7)
sizePolicy.setHeightForWidth(self.session_programs.sizePolicy().hasHeightForWidth())
self.session_programs.setSizePolicy(sizePolicy)
self.session_programs.setObjectName("session_programs")
self.verticalLayout_5 = QtWidgets.QVBoxLayout(self.session_programs)
self.verticalLayout_5.setContentsMargins(0, 0, 0, 0)
self.verticalLayout_5.setSpacing(0)
self.verticalLayout_5.setObjectName("verticalLayout_5")
self.loadedSessionsLauncher = QtWidgets.QTreeWidget(self.session_programs)
self.loadedSessionsLauncher.setDragDropMode(QtWidgets.QAbstractItemView.DragDrop)
self.loadedSessionsLauncher.setSelectionMode(QtWidgets.QAbstractItemView.NoSelection)
self.loadedSessionsLauncher.setIconSize(QtCore.QSize(64, 64))
self.loadedSessionsLauncher.setVerticalScrollMode(QtWidgets.QAbstractItemView.ScrollPerPixel)
self.loadedSessionsLauncher.setHorizontalScrollMode(QtWidgets.QAbstractItemView.ScrollPerPixel)
self.loadedSessionsLauncher.setObjectName("loadedSessionsLauncher")
self.loadedSessionsLauncher.headerItem().setText(0, "1")
self.verticalLayout_5.addWidget(self.loadedSessionsLauncher)
self.session_loaded = QtWidgets.QGroupBox(self.hSplitterLauncherClients)
self.session_loaded.setObjectName("session_loaded")
self.verticalLayout_6 = QtWidgets.QVBoxLayout(self.session_loaded)
self.verticalLayout_6.setContentsMargins(0, 0, 0, 0)
self.verticalLayout_6.setSpacing(0)
self.verticalLayout_6.setObjectName("verticalLayout_6")
self.loadedSessionClients = QtWidgets.QTreeWidget(self.session_loaded)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(3)
sizePolicy.setHeightForWidth(self.loadedSessionClients.sizePolicy().hasHeightForWidth())
self.loadedSessionClients.setSizePolicy(sizePolicy)
self.loadedSessionClients.setDragDropMode(QtWidgets.QAbstractItemView.DropOnly)
self.loadedSessionClients.setAlternatingRowColors(True)
self.loadedSessionClients.setVerticalScrollMode(QtWidgets.QAbstractItemView.ScrollPerPixel)
self.loadedSessionClients.setHorizontalScrollMode(QtWidgets.QAbstractItemView.ScrollPerPixel)
self.loadedSessionClients.setObjectName("loadedSessionClients")
self.loadedSessionClients.headerItem().setText(0, "1")
self.verticalLayout_6.addWidget(self.loadedSessionClients)
self.loadedSessionDescriptionGroupBox = QtWidgets.QGroupBox(self.vSplitterProgramsLog)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(2)
sizePolicy.setHeightForWidth(self.loadedSessionDescriptionGroupBox.sizePolicy().hasHeightForWidth())
self.loadedSessionDescriptionGroupBox.setSizePolicy(sizePolicy)
self.loadedSessionDescriptionGroupBox.setObjectName("loadedSessionDescriptionGroupBox")
self.verticalLayout_2 = QtWidgets.QVBoxLayout(self.loadedSessionDescriptionGroupBox)
self.verticalLayout_2.setContentsMargins(0, 0, 0, 0)
self.verticalLayout_2.setSpacing(0)
self.verticalLayout_2.setObjectName("verticalLayout_2")
self.loadedSessionDescription = QtWidgets.QPlainTextEdit(self.loadedSessionDescriptionGroupBox)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.loadedSessionDescription.sizePolicy().hasHeightForWidth())
self.loadedSessionDescription.setSizePolicy(sizePolicy)
self.loadedSessionDescription.setObjectName("loadedSessionDescription")
self.verticalLayout_2.addWidget(self.loadedSessionDescription)
self.verticalLayout_4.addWidget(self.vSplitterProgramsLog)
self.detailedStackedWidget.addWidget(self.stack_loaded_session)
self.horizontalLayout.addWidget(self.detailedStackedWidget)
self.tabbyCat.addTab(self.tab_detailed, "")
self.tab_information = QtWidgets.QWidget()
self.tab_information.setObjectName("tab_information")
self.tabbyCat.addTab(self.tab_information, "")
self.verticalLayout.addWidget(self.tabbyCat)
MainWindow.setCentralWidget(self.centralwidget)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 953, 20))
self.menubar.setObjectName("menubar")
self.menuControl = QtWidgets.QMenu(self.menubar)
self.menuControl.setObjectName("menuControl")
self.menuSession = QtWidgets.QMenu(self.menubar)
self.menuSession.setObjectName("menuSession")
self.menuClientNameId = QtWidgets.QMenu(self.menubar)
self.menuClientNameId.setObjectName("menuClientNameId")
MainWindow.setMenuBar(self.menubar)
self.actionMenuQuit = QtWidgets.QAction(MainWindow)
self.actionMenuQuit.setObjectName("actionMenuQuit")
self.actionAbout = QtWidgets.QAction(MainWindow)
self.actionAbout.setObjectName("actionAbout")
self.actionManual = QtWidgets.QAction(MainWindow)
self.actionManual.setObjectName("actionManual")
self.actionHide_in_System_Tray = QtWidgets.QAction(MainWindow)
self.actionHide_in_System_Tray.setObjectName("actionHide_in_System_Tray")
self.actionSessionAddClient = QtWidgets.QAction(MainWindow)
self.actionSessionAddClient.setObjectName("actionSessionAddClient")
self.actionSessionSave = QtWidgets.QAction(MainWindow)
self.actionSessionSave.setObjectName("actionSessionSave")
self.actionSessionSaveAs = QtWidgets.QAction(MainWindow)
self.actionSessionSaveAs.setObjectName("actionSessionSaveAs")
self.actionSessionSaveAndClose = QtWidgets.QAction(MainWindow)
self.actionSessionSaveAndClose.setObjectName("actionSessionSaveAndClose")
self.actionSessionAbort = QtWidgets.QAction(MainWindow)
self.actionSessionAbort.setObjectName("actionSessionAbort")
self.actionClientStop = QtWidgets.QAction(MainWindow)
self.actionClientStop.setObjectName("actionClientStop")
self.actionClientResume = QtWidgets.QAction(MainWindow)
self.actionClientResume.setObjectName("actionClientResume")
self.actionClientSave_separately = QtWidgets.QAction(MainWindow)
self.actionClientSave_separately.setObjectName("actionClientSave_separately")
self.actionClientRemove = QtWidgets.QAction(MainWindow)
self.actionClientRemove.setObjectName("actionClientRemove")
self.actionClientToggleVisible = QtWidgets.QAction(MainWindow)
self.actionClientToggleVisible.setObjectName("actionClientToggleVisible")
self.actionShow_All_Clients = QtWidgets.QAction(MainWindow)
self.actionShow_All_Clients.setObjectName("actionShow_All_Clients")
self.actionHide_All_Clients = QtWidgets.QAction(MainWindow)
self.actionHide_All_Clients.setObjectName("actionHide_All_Clients")
self.actionRebuild_Program_Database = QtWidgets.QAction(MainWindow)
self.actionRebuild_Program_Database.setObjectName("actionRebuild_Program_Database")
self.actionClientRename = QtWidgets.QAction(MainWindow)
self.actionClientRename.setObjectName("actionClientRename")
self.menuControl.addAction(self.actionRebuild_Program_Database)
self.menuControl.addAction(self.actionHide_in_System_Tray)
self.menuControl.addAction(self.actionMenuQuit)
self.menuSession.addAction(self.actionSessionAddClient)
self.menuSession.addAction(self.actionSessionSave)
self.menuSession.addAction(self.actionSessionSaveAs)
self.menuSession.addAction(self.actionSessionSaveAndClose)
self.menuSession.addAction(self.actionSessionAbort)
self.menuSession.addSeparator()
self.menuSession.addAction(self.actionShow_All_Clients)
self.menuSession.addAction(self.actionHide_All_Clients)
self.menuClientNameId.addAction(self.actionClientRename)
self.menuClientNameId.addAction(self.actionClientToggleVisible)
self.menuClientNameId.addAction(self.actionClientSave_separately)
self.menuClientNameId.addAction(self.actionClientStop)
self.menuClientNameId.addAction(self.actionClientResume)
self.menuClientNameId.addSeparator()
self.menuClientNameId.addAction(self.actionClientRemove)
self.menubar.addAction(self.menuControl.menuAction())
self.menubar.addAction(self.menuSession.menuAction())
self.menubar.addAction(self.menuClientNameId.menuAction())

self.retranslateUi(MainWindow)
self.tabbyCat.setCurrentIndex(0)
self.quickStackedWidget.setCurrentIndex(1)
self.detailedStackedWidget.setCurrentIndex(0)
QtCore.QMetaObject.connectSlotsByName(MainWindow)

def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "Argodejo"))
self.quickNewSession.setText(_translate("MainWindow", "Start New Session"))
self.quickSessionNameLineEdit.setText(_translate("MainWindow", "Session Name Goes Here"))
self.quickSaveOpenSession.setText(_translate("MainWindow", "Save"))
self.quickCloseOpenSession.setText(_translate("MainWindow", "Save and Close"))
self.quickSessionNotesGroupBox.setTitle(_translate("MainWindow", "Session Notes"))
self.quickSessionClientsListWidget.setSortingEnabled(True)
self.tabbyCat.setTabText(self.tabbyCat.indexOf(self.tab_quick), _translate("MainWindow", "Quick View"))
self.button_new_session.setText(_translate("MainWindow", "New"))
self.button_load_selected_session.setText(_translate("MainWindow", "Load Selected"))
self.checkBoxNested.setText(_translate("MainWindow", "Tree View"))
self.session_programs.setTitle(_translate("MainWindow", "Double-click to load program"))
self.session_loaded.setTitle(_translate("MainWindow", "In current session"))
self.loadedSessionDescriptionGroupBox.setTitle(_translate("MainWindow", "Session Notes"))
self.tabbyCat.setTabText(self.tabbyCat.indexOf(self.tab_detailed), _translate("MainWindow", "Full View"))
self.tabbyCat.setTabText(self.tabbyCat.indexOf(self.tab_information), _translate("MainWindow", "Information"))
self.menuControl.setTitle(_translate("MainWindow", "Control"))
self.menuSession.setTitle(_translate("MainWindow", "SessionName"))
self.menuClientNameId.setTitle(_translate("MainWindow", "ClientNameId"))
self.actionMenuQuit.setText(_translate("MainWindow", "Quit"))
self.actionMenuQuit.setShortcut(_translate("MainWindow", "Ctrl+Shift+Q"))
self.actionAbout.setText(_translate("MainWindow", "About"))
self.actionManual.setText(_translate("MainWindow", "Manual"))
self.actionHide_in_System_Tray.setText(_translate("MainWindow", "Hide in System Tray"))
self.actionHide_in_System_Tray.setShortcut(_translate("MainWindow", "Ctrl+Q"))
self.actionSessionAddClient.setText(_translate("MainWindow", "Add Client (Prompt)"))
self.actionSessionAddClient.setShortcut(_translate("MainWindow", "A"))
self.actionSessionSave.setText(_translate("MainWindow", "Save"))
self.actionSessionSave.setShortcut(_translate("MainWindow", "Ctrl+S"))
self.actionSessionSaveAs.setText(_translate("MainWindow", "Save As"))
self.actionSessionSaveAs.setShortcut(_translate("MainWindow", "Ctrl+Shift+S"))
self.actionSessionSaveAndClose.setText(_translate("MainWindow", "Save and Close"))
self.actionSessionSaveAndClose.setShortcut(_translate("MainWindow", "Ctrl+W"))
self.actionSessionAbort.setText(_translate("MainWindow", "Abort"))
self.actionSessionAbort.setShortcut(_translate("MainWindow", "Ctrl+Shift+W"))
self.actionClientStop.setText(_translate("MainWindow", "Stop"))
self.actionClientStop.setShortcut(_translate("MainWindow", "Alt+O"))
self.actionClientResume.setText(_translate("MainWindow", "Resume"))
self.actionClientResume.setShortcut(_translate("MainWindow", "Alt+R"))
self.actionClientSave_separately.setText(_translate("MainWindow", "Save separately"))
self.actionClientSave_separately.setShortcut(_translate("MainWindow", "Alt+S"))
self.actionClientRemove.setText(_translate("MainWindow", "Remove"))
self.actionClientRemove.setShortcut(_translate("MainWindow", "Alt+X"))
self.actionClientToggleVisible.setText(_translate("MainWindow", "Toggle Visible"))
self.actionClientToggleVisible.setShortcut(_translate("MainWindow", "Alt+T"))
self.actionShow_All_Clients.setText(_translate("MainWindow", "Show All Clients"))
self.actionHide_All_Clients.setText(_translate("MainWindow", "Hide All Clients"))
self.actionRebuild_Program_Database.setText(_translate("MainWindow", "Rebuild Program Database"))
self.actionClientRename.setText(_translate("MainWindow", "Rename"))
self.actionClientRename.setShortcut(_translate("MainWindow", "F2"))

+ 670
- 0
qtgui/designer/mainwindow.ui View File

@@ -0,0 +1,670 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>MainWindow</class>
<widget class="QMainWindow" name="MainWindow">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>953</width>
<height>763</height>
</rect>
</property>
<property name="windowTitle">
<string>Argodejo</string>
</property>
<widget class="QWidget" name="centralwidget">
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QTabWidget" name="tabbyCat">
<property name="currentIndex">
<number>0</number>
</property>
<widget class="QWidget" name="tab_quick">
<attribute name="title">
<string>Quick View</string>
</attribute>
<layout class="QHBoxLayout" name="horizontalLayout_2">
<item>
<widget class="QStackedWidget" name="quickStackedWidget">
<property name="currentIndex">
<number>1</number>
</property>
<widget class="QWidget" name="page_quickSessionChooser">
<layout class="QVBoxLayout" name="verticalLayout_9">
<item>
<widget class="QPushButton" name="quickNewSession">
<property name="text">
<string>Start New Session</string>
</property>
<property name="autoDefault">
<bool>true</bool>
</property>
<property name="default">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QScrollArea" name="scrollArea">
<property name="widgetResizable">
<bool>true</bool>
</property>
<widget class="QWidget" name="quickSessionChooser">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>98</width>
<height>28</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout_7">
<item>
<spacer name="deleteMe">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>586</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="page_quickSessionLoaded">
<layout class="QVBoxLayout" name="verticalLayout_8">
<property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QLineEdit" name="quickSessionNameLineEdit">
<property name="text">
<string>Session Name Goes Here</string>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</item>
<item>
<widget class="QWidget" name="widget_2" native="true">
<layout class="QHBoxLayout" name="horizontalLayout_4">
<property name="leftMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<item>
<widget class="QPushButton" name="quickSaveOpenSession">
<property name="text">
<string>Save</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="quickCloseOpenSession">
<property name="text">
<string>Save and Close</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QSplitter" name="splitter">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<widget class="QGroupBox" name="quickSessionNotesGroupBox">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>1</verstretch>
</sizepolicy>
</property>
<property name="title">
<string>Session Notes</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_10">
<property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QPlainTextEdit" name="quickSessionNotesPlainTextEdit">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
</widget>
</item>
</layout>
</widget>
<widget class="QListWidget" name="quickSessionClientsListWidget">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>6</verstretch>
</sizepolicy>
</property>
<property name="viewMode">
<enum>QListView::IconMode</enum>
</property>
<property name="sortingEnabled">
<bool>true</bool>
</property>
</widget>
</widget>
</item>
</layout>
</widget>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="tab_detailed">
<attribute name="title">
<string>Full View</string>
</attribute>
<layout class="QHBoxLayout" name="horizontalLayout">
<property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QStackedWidget" name="detailedStackedWidget">
<property name="currentIndex">
<number>0</number>
</property>
<widget class="QWidget" name="stack_no_session">
<layout class="QHBoxLayout" name="l_2">
<property name="spacing">
<number>6</number>
</property>
<property name="leftMargin">
<number>9</number>
</property>
<property name="topMargin">
<number>9</number>
</property>
<property name="rightMargin">
<number>9</number>
</property>
<property name="bottomMargin">
<number>9</number>
</property>
<item>
<widget class="QWidget" name="widget" native="true">
<layout class="QVBoxLayout" name="verticalLayout_3">
<item>
<widget class="QPushButton" name="button_new_session">
<property name="text">
<string>New</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="button_load_selected_session">
<property name="text">
<string>Load Selected</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="checkBoxNested">
<property name="text">
<string>Tree View</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QTreeWidget" name="session_tree">
<column>
<property name="text">
<string notr="true">1</string>
</property>
</column>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="stack_loaded_session">
<layout class="QVBoxLayout" name="verticalLayout_4">
<property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>9</number>
</property>
<property name="topMargin">
<number>9</number>
</property>
<property name="rightMargin">
<number>9</number>
</property>
<property name="bottomMargin">
<number>9</number>
</property>
<item>
<widget class="QSplitter" name="vSplitterProgramsLog">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<widget class="QSplitter" name="hSplitterLauncherClients">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>7</verstretch>
</sizepolicy>
</property>
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="childrenCollapsible">
<bool>false</bool>
</property>
<widget class="QGroupBox" name="session_programs">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>7</verstretch>
</sizepolicy>
</property>
<property name="title">
<string>Double-click to load program</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_5">
<property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QTreeWidget" name="loadedSessionsLauncher">
<property name="dragDropMode">
<enum>QAbstractItemView::DragDrop</enum>
</property>
<property name="selectionMode">
<enum>QAbstractItemView::NoSelection</enum>
</property>
<property name="iconSize">
<size>
<width>64</width>
<height>64</height>
</size>
</property>
<property name="verticalScrollMode">
<enum>QAbstractItemView::ScrollPerPixel</enum>
</property>
<property name="horizontalScrollMode">
<enum>QAbstractItemView::ScrollPerPixel</enum>
</property>
<column>
<property name="text">
<string notr="true">1</string>
</property>
</column>
</widget>
</item>
</layout>
</widget>
<widget class="QGroupBox" name="session_loaded">
<property name="title">
<string>In current session</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_6">
<property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QTreeWidget" name="loadedSessionClients">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>3</verstretch>
</sizepolicy>
</property>
<property name="dragDropMode">
<enum>QAbstractItemView::DropOnly</enum>
</property>
<property name="alternatingRowColors">
<bool>true</bool>
</property>
<property name="verticalScrollMode">
<enum>QAbstractItemView::ScrollPerPixel</enum>
</property>
<property name="horizontalScrollMode">
<enum>QAbstractItemView::ScrollPerPixel</enum>
</property>
<column>
<property name="text">
<string notr="true">1</string>
</property>
</column>
</widget>
</item>
</layout>
</widget>
</widget>
<widget class="QGroupBox" name="loadedSessionDescriptionGroupBox">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>2</verstretch>
</sizepolicy>
</property>
<property name="title">
<string>Session Notes</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>