Python baseadminnode.BaseAdminGtkNode類代碼示例

    def __init__(self, state, admin):
        BaseAdminGtkNode.__init__(self, state, admin, title=_("Component"))

        self._startTime = None
        self._debugging = None
        self._initialFluMask = ''
        self._initialGstMask = ''

 def __init__(self, *args, **kwargs):
     BaseAdminGtkNode.__init__(self, *args, **kwargs)
     self._statistics = None
     self._shown = False
     self._stats = None
     self._link = None
     self._labels = {}

 def setUIState(self, state):
     BaseAdminGtkNode.setUIState(self, state)
     self.model.clear()
     for profile in self.uiState.get("monitored-profiles"):
         self.stateAppend(self.uiState, "monitored-profiles", profile)
     for subkey, fileinfo in self.uiState.get("pending-files").items():
         self.stateSetitem(self.uiState, "pending-files", subkey, fileinfo)

    def setUIState(self, state):
        BaseAdminGtkNode.setUIState(self, state)
        if not self.widget:
            return

        self.haveMetadata(state.get('metadata', {}))
        self.haveCodecInfo(state.get('codec-info', {}))

    def setDebugEnabled(self, enabled):
        BaseAdminGtkNode.setDebugEnabled(self, enabled)
        if self._debugging:
            self._debugging.set_property('visible', enabled)

        self._initialFluMask = getDebug()
        self._initialGstMask = os.environ.get('GST_DEBUG', '')

 def setUIState(self, state):
     BaseAdminGtkNode.setUIState(self, state)
     if not self.uiStateHandlers:
         self.uiStateHandlers = {'wave': self.waveSet,
                                 'frequency': self.frequencySet,
                                 'samplerate': self.samplerateSet}
     for k, handler in self.uiStateHandlers.items():
         handler(state.get(k))

    def setUIState(self, uiState):
        BaseAdminGtkNode.setUIState(self, uiState)

        # Ick; we don't get these otherwise.
        for key in uiState.keys():
            val = uiState.get(key)
            if val is not None:
                self.stateSet(uiState, key, uiState.get(key))

 def __init__(self, state, admin, effectName, title=None):
     """
     @param state: state of component this is a UI for
     @type  state: L{flumotion.common.planet.AdminComponentState}
     @param admin: the admin model that interfaces with the manager for us
     @type  admin: L{flumotion.admin.admin.AdminModel}
     """
     BaseAdminGtkNode.__init__(self, state, admin, title)
     self.effectName = effectName

 def setUIState(self, state):
     # will only be called when we have a widget tree
     BaseAdminGtkNode.setUIState(self, state)
     self.widget.show_all()
     for feeder in state.get("feeders"):
         self.addFeeder(state, feeder)
     sel = self.treeview.get_selection()
     if sel is not None:
         sel.select_iter(self.treemodel.get_iter_first())

 def setUIState(self, state):
     BaseAdminGtkNode.setUIState(self, state)
     if not self.uiStateHandlers:
         self.uiStateHandlers = {'signal': self.signalSet,
                                 'snr': self.snrSet,
                                 'ber': self.berSet,
                                 'unc': self.uncSet,
                                 'lock': self.lockSet}
     for k, handler in self.uiStateHandlers.items():
         handler(state.get(k))

 def __init__(self, state, admin):
     BaseAdminGtkNode.__init__(self, state, admin, title=_("Eaters"))
     # tree model is a model of id, uiState, StateWatcher
     # tree model contains eaters
     self.treemodel = None
     self.treeview = None
     self._selected = None # the watcher of the currently selected row
     self.labels = {}
     self._lastConnect = 0
     self._lastDisconnect = 0

 def __init__(self, state, admin):
     BaseAdminGtkNode.__init__(self, state, admin, title=_("Feeders"))
     # tree model is a model of id, uiState, StateWatcher, type
     # tree model contains feeders and their feeder clients
     # type is a str, 'feeder' or 'client'
     self.treemodel = None
     self.treeview = None
     self.selected = None
     self.labels = {}
     self._lastConnect = 0
     self._lastDisconnect = 0

 def setUIState(self, state):
     BaseAdminGtkNode.setUIState(self, state)
     if self._path and state.hasKey('allow-browsing') \
        and state.get('allow-browsing'):
         self.browser.setBaseUri(state.get('stream-url'))
     else:
         self.browser.hide_all()
         warning = gtk.Label()
         warning.set_markup(_('Browsing files is not allowed.'))
         warning.show()
         self.widget.pack_start(warning)

 def __init__(self, *args, **kwargs):
     BaseAdminGtkNode.__init__(self, *args, **kwargs)
     self._progress = None
     self._model = gtk.TreeStore(str, str, str, int)
     self._view = None
     self._errorText = None
     self._uiInitialized = False
     self._fields = {}
     self._valFormats = {}
     self._lblFormats = {}
     self._labels = {}
     self._iterIndex = {}
     self._targetsWarnings = {}
     self._targetsError = {}
     self._jobWarnings = []
     self._jobError = None
     self._status = None

 def __init__(self, state, admin, title=None):
     BaseAdminGtkNode.__init__(self, state, admin, title)
     # create widget
     self.widget = gtk.Table(2, 1)
     self.radioButton = {}
     self.radioButton["backup"] = gtk.RadioButton(label="Backup")
     self.radioButton["master"] = gtk.RadioButton(
         self.radioButton["backup"],
         label="Master")
     self.radioButtonHandlers = {}
     currentRow = 0
     for eaterName in self.radioButton:
         self.widget.attach(self.radioButton[eaterName], 0, 1, currentRow,
             currentRow+1, yoptions=gtk.FILL, xpadding=6, ypadding=6)
         currentRow = currentRow + 1
         self.radioButton[eaterName].show()
         sigID = self.radioButton[eaterName].connect(
             "toggled", self.cb_toggled, eaterName)
         self.radioButtonHandlers[eaterName] = sigID
     self.widget.show()