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()))
