Python sip.isdeleted函数代码示例

    def test_removeMapLayersByLayer(self):
        """ test removing map layers by layer"""
        store = QgsMapLayerStore()

        # test no crash with empty store
        store.removeMapLayers([None])

        l1 = createLayer('test')
        l2 = createLayer('test2')
        l3 = createLayer('test3')

        store.addMapLayers([l1, l2, l3])
        self.assertEqual(store.count(), 3)

        #remove bad layers
        store.removeMapLayers([None])
        self.assertEqual(store.count(), 3)

        # remove valid layers
        store.removeMapLayers([l1])
        self.assertEqual(store.count(), 2)

        # test that layer has been deleted
        self.assertTrue(sip.isdeleted(l1))

        # remove multiple
        store.removeMapLayers([l2, l3])
        self.assertEqual(store.count(), 0)
        self.assertTrue(sip.isdeleted(l2))
        self.assertTrue(sip.isdeleted(l3))

    def test_removeMapLayersByLayer(self):
        """ test removing map layers by layer"""
        QgsMapLayerRegistry.instance().removeAllMapLayers()

        # test no crash with empty registry
        QgsMapLayerRegistry.instance().removeMapLayers([None])

        l1 = createLayer('test')
        l2 = createLayer('test2')
        l3 = createLayer('test3')

        QgsMapLayerRegistry.instance().addMapLayers([l1, l2, l3])
        self.assertEqual(QgsMapLayerRegistry.instance().count(), 3)

        #remove bad layers
        QgsMapLayerRegistry.instance().removeMapLayers([None])
        self.assertEqual(QgsMapLayerRegistry.instance().count(), 3)

        # remove valid layers
        QgsMapLayerRegistry.instance().removeMapLayers([l1])
        self.assertEqual(QgsMapLayerRegistry.instance().count(), 2)

        # test that layer has been deleted
        self.assertTrue(sip.isdeleted(l1))

        # remove multiple
        QgsMapLayerRegistry.instance().removeMapLayers([l2, l3])
        self.assertEqual(QgsMapLayerRegistry.instance().count(), 0)
        self.assertTrue(sip.isdeleted(l2))
        self.assertTrue(sip.isdeleted(l3))

    def search(self, text):
        logging.debug('Doing search.')
        thread = QThread()

        worker = SearchWorker(text, time.time())
        worker.moveToThread(thread)

        thread.started.connect(worker.process)
        worker.finished.connect(thread.quit)
        worker.finished.connect(worker.deleteLater)
        worker.new_items.connect(functools.partial(self.repopulate, worker))
        thread.finished.connect(thread.deleteLater)

        self._threads.append(thread)
        self.workers.append(worker)
        thread.start()

        # Revert search bar color.
        palette = main_window.palette()
        brush = palette.brush(QPalette.Highlight).color()
        palette.setBrush(QPalette.Base, QBrush(brush))
        search_bar.setPalette(palette)

        # Clean up old threads.
        self._threads = [thread for thread in self._threads
                         if not sip.isdeleted(thread)]
        self.workers = [worker for worker in self.workers
                        if not sip.isdeleted(worker)]

    def test_removeMapLayerByLayer(self):
        """ test removing a map layer by layer """
        QgsMapLayerRegistry.instance().removeAllMapLayers()

        # test no crash with empty registry
        QgsMapLayerRegistry.instance().removeMapLayer('bad')
        QgsMapLayerRegistry.instance().removeMapLayer(None)

        l1 = createLayer('test')
        l2 = createLayer('test2')

        QgsMapLayerRegistry.instance().addMapLayers([l1, l2])
        self.assertEqual(QgsMapLayerRegistry.instance().count(), 2)

        #remove bad layers
        QgsMapLayerRegistry.instance().removeMapLayer(None)
        self.assertEqual(QgsMapLayerRegistry.instance().count(), 2)
        l3 = createLayer('test3')
        QgsMapLayerRegistry.instance().removeMapLayer(l3)
        self.assertEqual(QgsMapLayerRegistry.instance().count(), 2)

        # remove valid layers
        QgsMapLayerRegistry.instance().removeMapLayer(l1)
        self.assertEqual(QgsMapLayerRegistry.instance().count(), 1)

        # test that layer has been deleted
        self.assertTrue(sip.isdeleted(l1))

        # remove second layer
        QgsMapLayerRegistry.instance().removeMapLayer(l2)
        self.assertEqual(QgsMapLayerRegistry.instance().count(), 0)
        self.assertTrue(sip.isdeleted(l2))

    def slotFlashTimeout(self):
        '''Handle flashing of UI components.'''

        # because we're flashing random UI components, the C++ object
        # might be deleted, so we have to check before doing things to
        # it: hence the sip.isdeleted

        if ( self.flash is not self.oldflash and self.oldflash is not None
             and not sip.isdeleted(self.oldflash) ):
            # clear any flashing on previous widget
            self.oldflash.setStyleSheet('')
            self.oldflash = None

        if self.flash is not None and not sip.isdeleted(self.flash):
            # set flash state and toggle variable
            if self.flashon:
                self.flash.setStyleSheet('background: yellow;')
            else:
                self.flash.setStyleSheet('')
            self.flashon = not self.flashon
            self.oldflash = self.flash

            # stop flashing after N iterations
            self.flashct -= 1
            if self.flashct == 0:
                self.flash = None

 def onclose(e):
     print 'destroying frame', f
     print 'BEFORE: isdeleted?', sip.isdeleted(f)
     print sip.dump(f)
     f.Destroy()
     #sip.setdeleted(f)
     print 'AFTER: isdeleted?', sip.isdeleted(f)
     print sip.dump(f)

    def _cleanup(self):
        """
        Delete the thread.
        """

        if self._thread:
            if not sip.isdeleted(self) and not sip.isdeleted(self._thread):
                if self._thread.isRunning():
                    self._thread.quit()
                    if not self._thread.wait(3000):
                        self._thread.terminate()
                        self._thread.wait()
                self._thread.deleteLater()

    def threadCleanup(self):
        if (self.mesh_thread is not None):
            if (sip.isdeleted(self.mesh_thread) == False):
                if (isinstance(self.mesh_thread,MeshThread)):
                    self.mesh_thread.deleteLater()
                    self.mesh_thread = None

        if (self.thread is not None):
            if (sip.isdeleted(self.thread) == False):
                if (isinstance(self.thread,QThread)):
                    self.thread.quit()
                    self.thread.wait()
                    self.thread.deleteLater()
                    self.thread = None

 def g_proxy(self, *args, **kwargs):
     g = func(self, *args, **kwargs)
     result = None
     while not sip.isdeleted(self):
         result = g.send(result)
         try:
             result = yield result
         except (GeneratorExit, StopIteration):
             break
         except Exception:
             if not sip.isdeleted(self):
                 g.throw(*sys.exc_info()) # NB: can raise anything and we'll propagate it
             else:
                 log.debug("Ignored exception on deleted object", exc_info=True)
     g.close()

    def purgeDeletedWidgets():
        """Finds old references to stashed fields and deletes them"""
        toremove = []
        for field in AbstractEditorWidget.funit_fields:
            if sip.isdeleted(field):
                toremove.append(field)
        for field in toremove:
            AbstractEditorWidget.funit_fields.remove(field)

        toremove = []
        for field in AbstractEditorWidget.tunit_fields:
            if sip.isdeleted(field):
                toremove.append(field)
        for field in toremove:
            AbstractEditorWidget.tunit_fields.remove(field)

    def __init__(self,layer,style,renderer,controller):
        QgsRendererV2Widget.__init__(self, layer, style)

        self._controller=controller

        if renderer is not None and renderer.type() != VectorFieldRenderer.rendererName:
            renderer=None

        import sip
        if renderer is not None and sip.isdeleted(renderer):
            renderer=None

        if renderer is not None and not isinstance(renderer,VectorFieldRenderer):
            renderer=self._controller.findLayerRenderer(layer)

        self.r = VectorFieldRenderer() if renderer is None else renderer

        self._layer=layer
        self.validLayer = True
        if layer is None or layer.type() != QgsMapLayer.VectorLayer or layer.geometryType() != QGis.Point:
           self.setupBlankUi(layer)
           self.validLayer = False
           return

        self._mode = VectorFieldRenderer.Cartesian
        self._ellipsemode = VectorFieldRenderer.NoEllipse
        self.buildWidget()
        self.setupLayer(layer)
        self.loadFromRenderer()
        # Try creating a new renderer to save to ...
        self.r=VectorFieldRenderer()

    def exit(self):
        """Destroy the Qt main event loop.

        """
        GRobot.exit_lock.acquire()
        if not self._deleted:
            if self.inspector:
                self.inspector.close()
                sip.delete(self.inspector)

            if self.display:
                self.webview.close()
                sip.delete(self.webview)

            if self.page and not sip.isdeleted(self.page):
                sip.delete(self.page)

            GRobot._liveRobot -= 1

            if GRobot._liveRobot == 0 and GRobot._loop is not None:
                GRobot._kill_loop = gevent.spawn_later(20, self.kill_loop)

            self._deleted = True

        GRobot.exit_lock.release()

 def break_cycles(self):
     for tab in self.tabs:
         if not sip.isdeleted(tab):
             self.stack.removeWidget(tab)
             tab.break_cycles()
             tab.deleteLater()
     self.tabs = []

def test_wrapper():
    "test wrapped objects' __nonzero__"

    f = wx.Frame(None)

    assert not sip.isdeleted(f)
    assert f

    weak_f = ref(f)
    f.Destroy()

    # calling ProcessIdle here forces wxApp::DeletePendingObjects(), which
    # deletes all objects from the wxPendingDelete list
    wx.GetApp().ProcessIdle()

    assert sip.isdeleted(f)

    def _focus_changed(self, old, new):
        """ Handle a change in focus that affects the current tab. """

        # It is possible for the C++ layer of this object to be deleted between
        # the time when the focus change signal is emitted and time when the
        # slots are dispatched by the Qt event loop. This may be a bug in PyQt4.
        if sip.isdeleted(self):
            return

        if self._repeat_focus_changes:
            self.emit(QtCore.SIGNAL('focusChanged(QWidget *,QWidget *)'), old, new)

        if isinstance(new, _DragableTabBar):
            ntw = new.parent()
            ntidx = ntw.currentIndex()
        else:
            ntw, ntidx = self._tab_widget_of(new)

        if ntw is not None:
            self._set_current_tab(ntw, ntidx)
            
        # See if the widget that has lost the focus is ours.
        otw, _ = self._tab_widget_of(old)

        if otw is not None or ntw is not None:
            if ntw is None:
                nw = None
            else:
                nw = ntw.widget(ntidx)
    
            self.emit(QtCore.SIGNAL('hasFocus'), nw)