def __init__(self, distributedObjects): QObject.__init__(self) self.distributedObjects = distributedObjects self.gdbioView = GdbIoView(self.distributedObjects.debugController) self.distributedObjects.signalProxy.insertDockWidgets.connect(self.insertDockWidgets)
def __init__(self,username,containerItem = None,parent = None): QObject.__init__(self,parent) HashableMixin.__init__(self) self._username = username self._contentItems = [] self._authorizer = Authorizer(self._username) self._containerItem = containerItem
def __init__(self, data, parent=None): QObject.__init__(self, parent) self.populated = False self.itemData = data self.childItems = [] if parent: parent.appendChild(self)
def __init__(self, framework, mainWindow): QObject.__init__(self, mainWindow) self.framework = framework self.mainWindow = mainWindow self.mainWindow.crawlerSpiderSequenceCheckBox.stateChanged.connect( self.handle_crawlerSpiderSequenceCheckBox_stateChanged ) self.mainWindow.crawlerSpiderStartButton.clicked.connect(self.handle_spiderStart_clicked) self.mainWindow.crawlerSpiderStopButton.clicked.connect(self.handle_spiderStop_clicked) self.mainWindow.crawlerSpiderClearQueueButton.clicked.connect(self.handle_spiderClearQueue_clicked) self.mainWindow.crawlerSpiderPendingResponsesClearButton.clicked.connect( self.handle_spiderClearPendingResponses_clicked ) self.mainWindow.crawlerSpiderPendingResponsesResetButton.clicked.connect( self.handle_spiderResetPendingResponses_clicked ) self.mainWindow.crawlerSpiderStartButton.setEnabled(True) self.mainWindow.crawlerSpiderStopButton.setEnabled(False) self.setup_spider_window() self.Data = None self.cursor = None self.framework.subscribe_database_events(self.db_attach, self.db_detach) self.framework.subscribe_sequences_changed(self.fill_sequences)
def __init__(self, widget): QObject.__init__(self) self.parent = widget self.ser = serial.Serial() self.mutex = QtCore.QMutex(mode=QtCore.QMutex.Recursive) self.moveThread = thread.WorkerThread() self.moveThread.canDropJobs = True
def __init__(self, navigationInterpreter, positionModel, editor): QObject.__init__(self) self.baseInterpret = navigationInterpreter self.posModel = positionModel self.rubberBand = QRubberBand(QRubberBand.Rectangle, editor) self.origin = QPoint() self.originpos = object()
def __init__(self, source_node, source_channel, sink_node, sink_channel, enabled=True, properties=None, parent=None): QObject.__init__(self, parent) self.source_node = source_node if isinstance(source_channel, six.string_types): source_channel = source_node.output_channel(source_channel) elif source_channel not in source_node.output_channels(): raise ValueError("%r not in in nodes output channels." \ % source_channel) self.source_channel = source_channel self.sink_node = sink_node if isinstance(sink_channel, six.string_types): sink_channel = sink_node.input_channel(sink_channel) elif sink_channel not in sink_node.input_channels(): raise ValueError("%r not in in nodes input channels." \ % source_channel) self.sink_channel = sink_channel if not compatible_channels(source_channel, sink_channel): raise IncompatibleChannelTypeError( "Cannot connect %r to %r" \ % (source_channel.type, sink_channel.type) ) self.__enabled = enabled self.__dynamic_enabled = False self.__tool_tip = "" self.properties = properties or {}
def __init__(self): QObject.__init__(self) TestRunner.__init__(self) self.verdict = None self.launcher = None self.launcher_kwargs = {} self.run_error = False
def __init__(self, parent = None): """ Constructor @param parent reference to the parent object (QObject) """ QObject.__init__(self, parent)
def __init__(self,editor,connectionInput,boxListModel, delegateMethod=None): ''' Class which controls all boxes on the scene :param scene: :param connectionInput: The imput slot to which connect all the new boxes :param boxListModel: ''' scene = editor.imageScenes[2] self._editor = editor QObject.__init__(self,parent=scene.parent()) self._setUpRandomColors() self.scene=scene self.connectionInput=connectionInput self._currentBoxesList=[] #self._currentActiveItem=[] #self.counter=1000 self.currentColor=self._getNextBoxColor() self.boxListModel=boxListModel self.scene.selectionChanged.connect(self.handleSelectionChange) boxListModel.boxRemoved.connect(self.deleteItem) boxListModel.signalSaveAllBoxesToCSV.connect(self.saveBoxesToCSV) self.delegateMethod = delegateMethod
def __init__(self, destdir, persist_limit, **kwargs): QObject.__init__(self) persist_limit = PersistLimit(persist_limit) BuildDownloadManager.__init__(self, destdir, session=get_http_session(), persist_limit=persist_limit, **kwargs)
def __init__(self, gelement, parent=None): QObject.__init__(self, parent) self._gelement = gelement self._gelement.get_bus().add_signal_watch() self._gelement.get_bus().connect('message', self.cb_bus) if GObjectLoop._instance is None: GObjectLoop()
def __init__(self, navigationInterpreter, positionModel, BoxContr, widget): ''' Class which interacts directly with the image scene :param navigationInterpreter: :param positionModel: :param BoxContr: :param widget: The main widget ''' QObject.__init__(self) self.baseInterpret = navigationInterpreter self._posModel = positionModel self.rubberBand = RedRubberBand(QRubberBand.Rectangle, widget) self.boxController=BoxContr self.leftClickReleased.connect(BoxContr.addNewBox) self.rightClickReceived.connect(BoxContr.onChangedPos) #self.deleteSelectedItemsSignal.connect(BoxContr.deleteSelectedItems) self.origin = QPoint() self.originpos = object()
def __init__( self, tiling, stackedImageSources, cache_size=100, request_queue_size=100000, n_threads=2, layerIdChange_means_dirty=False, parent=None ): QObject.__init__( self, parent = parent ) self.tiling = tiling self.axesSwapped = False self._sims = stackedImageSources self._cache_size = cache_size self._request_queue_size = request_queue_size self._n_threads = n_threads self._layerIdChange_means_dirty = layerIdChange_means_dirty self._current_stack_id = self._sims.stackId self._cache = _TilesCache(self._current_stack_id, self._sims, maxstacks=self._cache_size) self._sims.layerDirty.connect(self._onLayerDirty) self._sims.visibleChanged.connect(self._onVisibleChanged) self._sims.opacityChanged.connect(self._onOpacityChanged) self._sims.sizeChanged.connect(self._onSizeChanged) self._sims.orderChanged.connect(self._onOrderChanged) self._sims.stackIdChanged.connect(self._onStackIdChanged) if self._layerIdChange_means_dirty: self._sims.layerIdChanged.connect(self._onLayerIdChanged) self._keepRendering = True
def __init__(self, x, y, filename, mythDB, startAtEnd = False): QObject.__init__(self) self.filename = filename self.mythDB = mythDB self.startAtEnd = startAtEnd self.ended = False self.lastPosition = 0 self.emitFinished = True self.currentChannel = None self.previousChannel = None self.guide = None self.commskip = True self.getSkipList() self.bookmark = self.mythDB.bookmark(self.filename) self.program = self.mythDB.getProgram(self.filename) self.recording = self.mythDB.programInUse(self.program) self.videoOutput = VideoOutput(None, self.keyPressHandler) self.createOverlays() self.videoOutput.readyForOverlay.connect(self.placeOverlays) self.videoOutput.move(x, y) self.videoOutput.showFullScreen() self.startBackend()
def __init__(self, parent=None, name=None, *args, **kwargs): """ Initializes the class. :param parent: Object parent. :type parent: QObject :param name: Component name. :type name: unicode :param \*args: Arguments. :type \*args: \* :param \*\*kwargs: Keywords arguments. :type \*\*kwargs: \*\* """ LOGGER.debug("> Initializing '{0}()' class.".format(self.__class__.__name__)) QObject.__init__(self, parent, *args, **kwargs) # --- Setting class attributes. --- self.__name = None self.name = name self.__activated = False self.__initialized = False self.__deactivatable = True
def __init__(self, features, uid, errors): QObject.__init__(self) self.features = features self.last_fid = features[-1][0] self.errors = errors self.uid = uid self.vertices_occur = {} self.edges_occur = {} self.f_dict = {} self.self_loops = [] for i in self.features: self.f_dict[i[0]] = [i[1], i[2]] for vertex in vertices_from_wkt_2(i[2]): break first = vertex for vertex in vertices_from_wkt_2(i[2]): pass last = vertex try: self.vertices_occur[first] += [i[0]] except KeyError, e: self.vertices_occur[first] = [i[0]] try: self.vertices_occur[last] += [i[0]] except KeyError, e: self.vertices_occur[last] = [i[0]]
def __init__(self, theHazardLayer, theExposureLayer, theFunction): """Constructor for the impact calculator thread. Args: * Hazard layer: InaSAFE read_layer object containing the Hazard data. * Exposure layer: InaSAFE read_layer object containing the Exposure data. * Function: a InaSAFE function that defines how the Hazard assessment will be computed. Returns: None Raises: InsufficientParametersException if not all parameters are set. Requires three parameters to be set before execution can take place: """ threading.Thread.__init__(self) QObject.__init__(self) self._hazardLayer = theHazardLayer self._exposureLayer = theExposureLayer self._function = theFunction self._impactLayer = None self._result = None self._exception = None self._traceback = None
def __init__( self, osm_file, layers=OSM_LAYERS, white_list_column=WHITE_LIST, delete_empty_layers=False, load_only=False, osm_conf=None): self.__osmFile = osm_file self.__layers = layers if not white_list_column: white_list_column = { 'multilinestrings': None, 'points': None, 'lines': None, 'multipolygons': None} self.__whiteListColumn = white_list_column self.__deleteEmptyLayers = delete_empty_layers self.__loadOnly = load_only # If an osm_conf is provided ? if not osm_conf: current_dir = dirname(realpath(__file__)) self._osm_conf = join(current_dir, 'QuickOSMconf.ini') else: self._osm_conf = osm_conf.encode("utf-8") QObject.__init__(self)
def __init__(self, parent = None): QObject.__init__(self, parent) self.jinja = Environment(loader = FileSystemLoader("data/templates"), autoescape = True) self.jinja.filters["likes"] = filter_likes self.jinja.filters["twitterise"] = filter_twitterise self.jinja.filters["timesince"] = filter_timesince self.mapper = Mapper() self.mapper.connect("/", controller = "LolViews", action = "feed") self.mapper.connect("/login", controller = "LolViews", action = "login") self.mapper.connect("/user/:user", controller = "LolViews", action = "feed") self.notes = NotificationServer() from PyQt4.QtCore import QSettings settings = QSettings() if settings.contains("session"): from cPickle import loads self.session = loads(str(settings.value("session").toString())) else: self.session = Session() self.ff = FriendFeedAPI(self.session) self.deferredResponses = set()
def __init__(self, weboob, parent=None): QObject.__init__(self, parent) self.weboob = weboob self.weboob.callbacks['login'] = self.callback(self.LoginRequest) self.mutex = QMutex() self.requests = [] self.connect(self, SIGNAL('new_request'), self.do_request)
def __init__(self): """Constructor for the KeywordIO object.""" QObject.__init__(self) # path to sqlite db path self.keyword_db_path = None self.setup_keyword_db_path() self.connection = None
def __init__(self, hazard_layer, exposure_layer, function): """Constructor for the impact calculator thread. :param hazard_layer: read_layer object containing the Hazard. data. :type hazard_layer: read_layer :param exposure_layer: read_layer object containing the Exposure data. :type exposure_layer: read_layer :param function: Function that defines how the Hazard assessment will be computed. :type function: FunctionProvider :raises: InsufficientParametersError if not all parameters are set. """ threading.Thread.__init__(self) QObject.__init__(self) self._hazardLayer = hazard_layer self._exposureLayer = exposure_layer self._function = function self._impactLayer = None self._result = None self._exception = None self._traceback = None
def __init__(self, cacheSize=1024*1024*100, userAgent='(PyQt) TileMap 1.2', parent=None): QObject.__init__(self, parent=parent) self._manager = None self._cache = None self._cacheSize = cacheSize self._userAgent = userAgent self._tileInDownload = dict()
def __init__(self, deserialize_fn, cfg_name, set_fn_name, parent=None): QObject.__init__(self, parent) #name of a model -> model self.models = {} if isinstance(parent, Logger): self.logger = parent else: self.logger = Logger(cfg_name) self.cfg = None self.validation_callbacks = [] self.passed_args = [] self.effective_callbacks = [] self.__forgettables = {} self.backup = None cls = self.__class__ setattr( cls, cfg_name, property(fget=cls.getCfg, fset=cls.setCfg) ) setattr( self, set_fn_name, self.setCfg ) setattr( self.__class__, 'deserialize', staticmethod(deserialize_fn) )
def __init__(self, iface, dialog_ui, bbox_tool): """ Constructor for the dialog tool :param iface: The QGIS Interface :param dialog_ui: The dialog GUI :param bbox_tool The bounding box tool :return: dialog tool """ QObject.__init__(self, None) self.iface = iface self.dialog_ui = dialog_ui self.bbox_tool = bbox_tool self.progress_bar = None self.progress_message_bar = None self.progress_message_bar_widget = None self.search_thread_pool = QThreadPool() self.search_lock = Lock() self.export_thread_pool = QThreadPool() self.export_lock = Lock() self.query = None self.previous_credentials = None self.export_file = None self.footprint_layer = None self.filters = CatalogFilters(self.dialog_ui) self.dialog_ui.aoi_button.clicked.connect(self.aoi_button_clicked) self.dialog_ui.reset_button.clicked.connect(self.reset_button_clicked) self.dialog_ui.export_button.clicked.connect(self.export_button_clicked) self.bbox_tool.released.connect(self.search) self.model = None
def __init__(self, do_auto_repeat=True, repeat_delay=SDL_JOYSTICK_DEFAULT_AUTOREPEAT_DELAY, joystick_event_timeout=SDL_JOYSTICK_DEFAULT_EVENT_TIMEOUT, joystick_deadzone=JOYSTICK_DEADZONE, joystick_sensitivity=JOYSTICK_SENSITIVITY): QObject.__init__(self) self.joystick_timer = QTimer() self.deadzones = {} self.sensitivities = {} self.axis_repeat_timers = {} self.button_repeat_timers = {} self.hat_repeat_timers = {} self.axes = self.buttons = self.hats = {} self.num_axes = self.num_buttons = self.num_hats = self.num_trackballs = 0 self.joystick = None self.auto_repeat = do_auto_repeat self.auto_repeat_delay = repeat_delay self.event_timeout = joystick_event_timeout self.joystick_deadzone = joystick_deadzone self.joystick_sensitivity = joystick_sensitivity self.joystick_names = [] self.init()
def __init__(self, distributedObjects): """ init tracepoint controller and members. @param distributedObjects: passing distributed objects @note There are following signals: \n * insertDockWidgets() : necessary for plugin system\n * clicked(QModelIndex): if a row in tracepointView is clicked\n * cleanupModels(): clear Tracepoints\n * runClicked((): clear Tracepoint Data on every click on run button\n """ QObject.__init__(self) self.distributedObjects = distributedObjects """@var self._model: (TracepointModel), this class provides the model for tracepointView""" self._model = TracepointModel(self.distributedObjects) """@var self.tracepointView: (TracepointView), this class presents data from _model""" self.tracepointView = TracepointView() self.tracepointView.tracepointView.setModel(self._model) #register with session manager to save Tracepoints self.distributedObjects.signalProxy.emitRegisterWithSessionManager(self, "Tracepoints") self.distributedObjects.signalProxy.insertDockWidgets.connect(self.insertDockWidgets) self.tracepointView.tracepointView.clicked.connect(self.updateWaveforms) self.distributedObjects.signalProxy.inferiorStoppedNormally.connect(self.updateWaveforms) self.distributedObjects.signalProxy.cleanupModels.connect(self._model.clearTracepoints) self.distributedObjects.signalProxy.runClicked.connect(self._model.clearTracepointData)
def __init__(self, fetch_config, test_runner, download_manager): QObject.__init__(self) self.fetch_config = fetch_config self.test_runner = test_runner self.download_manager = download_manager self.launch_arg = None self._build_info = None
def __init__(self): QObject.__init__(self) self._action = core.actionManager().addAction("mSettings/aSettings", _tr( "Settings.."), QIcon(':/enkiicons/settings.png')) self._action.setStatusTip(_tr( "Edit settigns..")) self._action.triggered.connect(self._onEditSettings)
def __init__(self, destdir, **kwargs): QObject.__init__(self) BuildDownloadManager.__init__(self, None, destdir, **kwargs)
def __init__(self, parent=None): QObject.__init__(self, parent) self.trackworker = None
def __init__(self, name): QObject.__init__(self) self.name = name self.data = {} self.valid = True
def __init__(self, parent): QObject.__init__(self, parent) self.settings = MySettings()
def __init__(self): QObject.__init__(self)
def __init__(self, isStdout): QObject.__init__(self) self.__isStdout = isStdout return
def __init__(self, parent): QObject.__init__(self, parent) parent.installEventFilter(self)
def __init__(self): QObject.__init__(self) self.translatedMap = self.translationMap()
def __init__(self): QObject.__init__(self) self.VFS = VFS.Get() self._selection = set()
def __init__(self, mainwindow): QObject.__init__(self) self.mainwindow = mainwindow self.bisector = None self.thread = None self.pending_threads = []
def __init__(self): QObject.__init__(self) tx.Ui_TxDialog.__init__(self)
def __init__(self, parent=None): QObject.__init__(self) self.state = self.ALL self._group_cache = {} self.iface = backend.pm.Iface() self.reset()
def __init__(self): QObject.__init__(self) self.threadRouter = ThreadRouter(self)
def __init__(self, parent=None, registry=None, cached_descriptions=None): QObject.__init__(self, parent) WidgetDiscovery.__init__(self, registry, cached_descriptions)
def __init__(self, composerView, iface): QObject.__init__(self, composerView) self._compView = composerView self._stdmTB = self.mainWindow().addToolBar("STDM Document Designer") self._selectMoveAction = None self._iface = iface #Container for custom editor widgets self._widgetMappings = {} #Hide default dock widgets if self.itemDock() is not None: self.itemDock().hide() if self.atlasDock() is not None: self.atlasDock().hide() if self.generalDock() is not None: self.generalDock().hide() # Remove default toolbars self._remove_composer_toolbar('mAtlasToolbar') self._remove_composer_toolbar('mComposerToolbar') #Create dock widget for configuring STDM data source self._stdmDataSourceDock = QDockWidget( QApplication.translate("ComposerWrapper", "STDM Data Source"), self.mainWindow()) self._stdmDataSourceDock.setObjectName("STDMDataSourceDock") self._stdmDataSourceDock.setMinimumWidth(300) self._stdmDataSourceDock.setFeatures(QDockWidget.DockWidgetMovable | QDockWidget.DockWidgetClosable) self.mainWindow().addDockWidget(Qt.RightDockWidgetArea, self._stdmDataSourceDock) self._dataSourceWidget = ComposerDataSourceSelector() self._stdmDataSourceDock.setWidget(self._dataSourceWidget) self._stdmDataSourceDock.show() #Re-insert dock widgets if self.generalDock() is not None: self.generalDock().show() if self.itemDock() is not None: self.itemDock().show() #Create dock widget for configuring STDM item properties self._stdmItemPropDock = QDockWidget( QApplication.translate("ComposerWrapper", "STDM item properties"), self.mainWindow()) self._stdmItemPropDock.setObjectName("STDMItemDock") self._stdmItemPropDock.setMinimumWidth(300) self._stdmItemPropDock.setFeatures(QDockWidget.DockWidgetMovable | QDockWidget.DockWidgetClosable) self.mainWindow().addDockWidget(Qt.RightDockWidgetArea, self._stdmItemPropDock) self._stdmItemPropDock.show() #Re-arrange dock widgets and push up STDM data source dock widget if self.generalDock() is not None: self.mainWindow().splitDockWidget(self._stdmDataSourceDock, self.generalDock(), Qt.Vertical) if self.itemDock() is not None: self.mainWindow().splitDockWidget(self._stdmDataSourceDock, self.itemDock(), Qt.Vertical) if self.generalDock() is not None: self.mainWindow().tabifyDockWidget(self.generalDock(), self.itemDock()) if self.itemDock() is not None: self.mainWindow().splitDockWidget(self.itemDock(), self._stdmItemPropDock, Qt.Vertical) #Set focus on composition properties window if self.generalDock() is not None: self.generalDock().activateWindow() self.generalDock().raise_() #Connect signals self.composition().itemRemoved.connect(self._onItemRemoved) self._dataSourceWidget.cboDataSource.currentIndexChanged.connect( self.propagateDataSourceSelection) self.composerView().selectedItemChanged.connect(self._onItemSelected) #Current template document file self._currDocFile = None #Copy of template document file self._copy_template_file = None self._selected_item_uuid = unicode() self._current_ref_table_index = -1
def __init__(self, parent=None, steps=[], user_install=False): QObject.__init__(self, parent) self.__interupt = False self.__queue = deque(steps) self.__user_install = user_install
def __init__(self, plugins_menu): QObject.__init__(self) self._plugins_menu = plugins_menu
def __init__(self, parent=None, steps=[]): QObject.__init__(self, parent) self.__interupt = False self.__queue = deque(steps)
def __init__(self, parent=None): QObject.__init__(self, parent) self._registry = None self._initialized = False self._providers = {}
def __init__(self, menuEdit, toolbar): QObject.__init__(self) undoAction = menuEdit.addAction(QIcon(resources.IMAGES['undo']), self.trUtf8("Undo (%s+Z)" % settings.OS_KEY)) redoAction = menuEdit.addAction(QIcon(resources.IMAGES['redo']), self.trUtf8("Redo (%s)" % resources.get_shortcut("Redo").toString( QKeySequence.NativeText))) cutAction = menuEdit.addAction(QIcon(resources.IMAGES['cut']), self.trUtf8("&Cut (%s+X)" % settings.OS_KEY)) copyAction = menuEdit.addAction(QIcon(resources.IMAGES['copy']), self.trUtf8("&Copy (%s+C)" % settings.OS_KEY)) pasteAction = menuEdit.addAction(QIcon(resources.IMAGES['paste']), self.trUtf8("&Paste (%s+V)" % settings.OS_KEY)) menuEdit.addSeparator() findAction = menuEdit.addAction(QIcon(resources.IMAGES['find']), self.trUtf8("Find (%s)" % resources.get_shortcut("Find").toString( QKeySequence.NativeText))) findReplaceAction = menuEdit.addAction( QIcon(resources.IMAGES['findReplace']), self.trUtf8("Find/Replace (%s)" % resources.get_shortcut("Find-replace").toString( QKeySequence.NativeText))) findWithWordAction = menuEdit.addAction( self.trUtf8("Find using word under cursor (%s)" % resources.get_shortcut("Find-with-word").toString( QKeySequence.NativeText))) findInFilesAction = menuEdit.addAction(QIcon(resources.IMAGES['find']), self.trUtf8("Find in Files (%s)" % resources.get_shortcut("Find-in-files").toString( QKeySequence.NativeText))) locatorAction = menuEdit.addAction(QIcon(resources.IMAGES['locator']), self.trUtf8("Code Locator (%s)" % resources.get_shortcut("Code-locator").toString( QKeySequence.NativeText))) menuEdit.addSeparator() upperAction = menuEdit.addAction( self.trUtf8("Convert selected Text to: UPPER")) lowerAction = menuEdit.addAction( self.trUtf8("Convert selected Text to: lower")) titleAction = menuEdit.addAction( self.trUtf8("Convert selected Text to: Title Word")) menuEdit.addSeparator() prefAction = menuEdit.addAction(QIcon(resources.IMAGES['pref']), self.trUtf8("Preference&s")) self.toolbar_items = { 'undo': undoAction, 'redo': redoAction, 'cut': cutAction, 'copy': copyAction, 'paste': pasteAction, 'find': findAction, 'find-replace': findReplaceAction, 'find-files': findInFilesAction, 'code-locator': locatorAction} self.connect(cutAction, SIGNAL("triggered()"), self._editor_cut) self.connect(copyAction, SIGNAL("triggered()"), self._editor_copy) self.connect(pasteAction, SIGNAL("triggered()"), self._editor_paste) self.connect(redoAction, SIGNAL("triggered()"), self._editor_redo) self.connect(undoAction, SIGNAL("triggered()"), self._editor_undo) self.connect(upperAction, SIGNAL("triggered()"), self._editor_upper) self.connect(lowerAction, SIGNAL("triggered()"), self._editor_lower) self.connect(titleAction, SIGNAL("triggered()"), self._editor_title) self.connect(findAction, SIGNAL("triggered()"), status_bar.StatusBar().show) self.connect(findWithWordAction, SIGNAL("triggered()"), status_bar.StatusBar().show_with_word) self.connect(findReplaceAction, SIGNAL("triggered()"), status_bar.StatusBar().show_replace) self.connect(findInFilesAction, SIGNAL("triggered()"), self._show_find_in_files) self.connect(locatorAction, SIGNAL("triggered()"), status_bar.StatusBar().show_locator) self.connect(prefAction, SIGNAL("triggered()"), self._show_preferences)
def __init__(self, tileSize=256, minZoom=2, maxZoom=18, parent=None): QObject.__init__(self, parent=parent) self._tileSize = tileSize self._minZoom = minZoom self._maxZoom = maxZoom
def __init__(self, toolbar): QObject.__init__(self) self._toolbar = toolbar
def __init__( self, cmd, ): QObject.__init__(self) self.cmd = cmd
def __init__(self): QObject.__init__(self) self.dialogs = {} self.namespace = None
def __init__(self, visaResource, instrument=None): # VisaInstrument.__init__(self, visaResource) QObject.__init__(self, instrument)
def __init__(self, cmd, session): QObject.__init__(self) self.cmd = cmd self.session = session
def __init__(self, DATA): Thread.__init__(self) QObject.__init__(self) DATA.wants_abort = False self.data = DATA #client data object
def __init__(self): """Constructor.""" QObject.__init__(self) self._repositories = {} self.load()
def __init__(self, processUrl): QObject.__init__(self) self.server = pystring(processUrl.host()) self.path = pystring(processUrl.path()) self.port = pystring(processUrl.port()) self.cookieSettings = "WPS-Cookie/" + self.server + ":" + self.port + self.path
def __init__(self, args, parent=None): QObject.__init__(self, parent) # variable declarations self.m_loadStatus = self.m_state = '' self.m_var = self.m_paperSize = self.m_loadScript_cache = {} self.m_verbose = args.verbose self.m_page = WebPage(self) self.m_clipRect = QRect() # setup the values from args self.m_script = args.script.read() self.m_scriptFile = args.script.name self.m_scriptDir = os.path.dirname(args.script.name) + '/' self.m_args = args.script_args self.m_upload_file = args.upload_file autoLoadImages = False if args.load_images == 'no' else True pluginsEnabled = True if args.load_plugins == 'yes' else False args.script.close() do_action('PhantomInitPre', Bunch(locals())) palette = self.m_page.palette() palette.setBrush(QPalette.Base, Qt.transparent) self.m_page.setPalette(palette) if not args.proxy: QNetworkProxyFactory.setUseSystemConfiguration(True) else: proxy = QNetworkProxy(QNetworkProxy.HttpProxy, args.proxy[0], int(args.proxy[1])) QNetworkProxy.setApplicationProxy(proxy) self.m_page.settings().setAttribute(QWebSettings.AutoLoadImages, autoLoadImages) self.m_page.settings().setAttribute(QWebSettings.PluginsEnabled, pluginsEnabled) self.m_page.settings().setAttribute( QWebSettings.FrameFlatteningEnabled, True) self.m_page.settings().setAttribute( QWebSettings.OfflineStorageDatabaseEnabled, True) self.m_page.settings().setAttribute(QWebSettings.LocalStorageEnabled, True) self.m_page.settings().setLocalStoragePath( QDesktopServices.storageLocation(QDesktopServices.DataLocation)) self.m_page.settings().setOfflineStoragePath( QDesktopServices.storageLocation(QDesktopServices.DataLocation)) # Ensure we have a document.body. self.m_page.mainFrame().setHtml('<html><body></body></html>') self.m_page.mainFrame().setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff) self.m_page.mainFrame().setScrollBarPolicy(Qt.Vertical, Qt.ScrollBarAlwaysOff) m_netAccessMan = NetworkAccessManager(args.disk_cache, args.ignore_ssl_errors, self) self.m_page.setNetworkAccessManager(m_netAccessMan) # inject our properties and slots into javascript self.m_page.mainFrame().javaScriptWindowObjectCleared.connect( self.inject) self.m_page.loadFinished.connect(self.finish) do_action('PhantomInitPost', Bunch(locals()))