Example #1
0
class Session:
    def __init__(self):
        self.client_list = []
        self.trashed_clients = []
        self.favorite_list = []
        self.recent_sessions = []
        self.name = ''
        self.path = ''
        self.notes = ''
        self.server_status = ray.ServerStatus.OFF

        self.is_renameable = True

        self.signaler = Signaler()
        self.patchbay_manager = PatchbayManager(self)

        server = GuiServerThread.instance()
        server.start()

        self.daemon_manager = DaemonManager(self)
        if CommandLineArgs.daemon_url:
            self.daemon_manager.set_osc_address(CommandLineArgs.daemon_url)
        elif CommandLineArgs.daemon_port:
            self.daemon_manager.set_osc_address(CommandLineArgs.daemon_port)
        elif not CommandLineArgs.out_daemon:
            self.daemon_manager.set_new_osc_address()

        # build nsm_child if NSM_URL in env
        self.nsm_child = None

        if CommandLineArgs.under_nsm:
            if CommandLineArgs.out_daemon:
                self.nsm_child = NsmChildOutside(self)
                self.daemon_manager.set_external()
            else:
                self.nsm_child = NsmChild(self)

        # build and show Main UI
        self.main_win = MainWindow(self)
        self.daemon_manager.finish_init()
        self.patchbay_manager.finish_init()
        server.finish_init(self)

        self.main_win.show()

        # display donations dialog under conditions
        if not RS.is_hidden(RS.HD_Donations):
            coreff_counter = RS.settings.value('coreff_counter', 0, type=int)
            coreff_counter += 1
            RS.settings.setValue('coreff_counter', coreff_counter)

            if coreff_counter % 44 == 29:
                self.main_win.donate(True)

    def quit(self):
        self.patchbay_manager.clear_all()
        self.main_win.hide()
        del self.main_win

    def is_running(self)->bool:
        return bool(self.server_status != ray.ServerStatus.OFF)

    def update_server_status(self, server_status: int):
        self.server_status = server_status

    def _set_name(self, session_name: str):
        self.name = session_name

    def _set_path(self, session_path: str):
        self.path = session_path

    def get_short_path(self):
        if self.path.startswith(CommandLineArgs.session_root):
            return self.path.replace(
                '%s/' % CommandLineArgs.session_root, '', 1)

        return self.path

    def get_client(self, client_id: str)->Client:
        for client in self.client_list:
            if client.client_id == client_id:
                return client

        if CommandLineArgs.debug:
            sys.stderr.write("gui_session does not contains client %s\n"
                             % client_id)
        return None

    def add_favorite(self, template_name: str, icon_name: str, factory: bool):
        server = GuiServerThread.instance()
        if server:
            server.to_daemon('/ray/favorites/add', template_name,
                            icon_name, int(factory))

    def remove_favorite(self, template_name: str, factory: bool):
        for favorite in self.favorite_list:
            if favorite.name == template_name and favorite.factory == factory:
                break

        server = GuiServerThread.instance()
        if server:
            server.to_daemon('/ray/favorites/remove', template_name, int(factory))

    def is_favorite(self, template_name: str, factory: bool):
        for favorite in self.favorite_list:
            if favorite.name == template_name and favorite.factory == factory:
                return True
        return False

    def set_daemon_options(self, options):
        self.main_win.set_daemon_options(options)
        for client in self.client_list:
            client.widget.set_daemon_options(options)
Example #2
0
class Session:
    def __init__(self):
        self.client_list = []
        self.trashed_clients = []
        self.favorite_list = []
        self.name = ''
        self.path = ''
        self.notes = ''
        self.is_running = False
        self.server_status = ray.ServerStatus.OFF

        self.is_renameable = True

        self._signaler = Signaler()

        server = GUIServerThread.instance()
        server.start()

        self._daemon_manager = DaemonManager(self)
        if CommandLineArgs.daemon_url:
            self._daemon_manager.setOscAddress(CommandLineArgs.daemon_url)
        elif CommandLineArgs.daemon_port:
            self._daemon_manager.setOscAddress(CommandLineArgs.daemon_port)
        elif not CommandLineArgs.out_daemon:
            self._daemon_manager.setNewOscAddress()

        # build nsm_child if NSM_URL in env
        self._nsm_child = None

        if CommandLineArgs.under_nsm:
            if CommandLineArgs.out_daemon:
                self._nsm_child = NSMChildOutside(self)
                self._daemon_manager.setExternal()
            else:
                self._nsm_child = NSMChild(self)

        # build and show Main UI
        self._main_win = MainWindow(self)

        self._daemon_manager.finishInit()
        server.finishInit(self)

        self._main_win.show()

        # display donations dialog under conditions
        if not RS.settings.value('hide_donations', False, type=bool):
            coreff_counter = RS.settings.value('coreff_counter', 0, type=int)
            coreff_counter += 1
            RS.settings.setValue('coreff_counter', coreff_counter)

            if coreff_counter % 44 == 29:
                self._main_win.donate(True)

        # The only way I found to not show Messages Dock by default.
        if not RS.settings.value('MainWindow/ShowMessages', False, type=bool):
            self._main_win.hideMessagesDock()

    def quit(self):
        self._main_win.hide()
        del self._main_win

    def setRunning(self, running: bool):
        self.is_running = running

    def isRunning(self):
        return bool(self.server_status != ray.ServerStatus.OFF)

    def updateServerStatus(self, server_status):
        self.server_status = server_status

    def setName(self, session_name):
        self.name = session_name

    def setPath(self, session_path):
        self.path = session_path

    def getShortPath(self):
        if self.path.startswith(CommandLineArgs.session_root):
            return self.path.replace('%s/' % CommandLineArgs.session_root, '',
                                     1)

        return self.path

    def getClient(self, client_id):
        for client in self.client_list:
            if client.client_id == client_id:
                return client

        raise NameError("gui_session does not contains client %s" % client_id)

    def removeAllClients(self):
        self.client_list.clear()

    def addFavorite(self, name, icon_name, factory, from_server=False):
        for favorite in self.favorite_list:
            if favorite.name == name and favorite.factory == factory:
                favorite.icon = icon_name
                return

        fav = ray.Favorite(name, icon_name, factory)
        self.favorite_list.append(fav)

        self._main_win.updateFavoritesMenu()

        if not from_server:
            server = GUIServerThread.instance()
            if server:
                server.toDaemon('/ray/favorites/add', name, icon_name,
                                int(factory))

    def removeFavorite(self, name, factory, from_server=False):
        for favorite in self.favorite_list:
            if favorite.name == name and favorite.factory == factory:
                self.favorite_list.remove(favorite)
                break

        self._main_win.updateFavoritesMenu()

        if not from_server:
            server = GUIServerThread.instance()
            if server:
                server.toDaemon('/ray/favorites/remove', name, int(factory))

    def setDaemonOptions(self, options):
        self._main_win.setDaemonOptions(options)
        for client in self.client_list:
            client.widget.setDaemonOptions(options)