def __launch(delegate):
   ''' 
   Runs the given (no-argument) delegate method in a 'safe' script environment.
   This environment will take care of all error handling, logging/debug stream,
   and other standard initialization behaviour before delegate() is called, and
   it will take care of cleaning everything up afterwards.
   ''' 
   try:
      # initialize the application resources (import directories, etc)
      Resources.initialize()
      
      # fire up the debug logging system
      log.install(ComicRack.MainWindow)
      
      # install a handler to catch uncaught Winforms exceptions
      def exception_handler(sender, event):
         log.handle_error(event.Exception)
      Application.ThreadException \
         += ThreadExceptionEventHandler(exception_handler)
         
      # fire up the localization/internationalization system
      i18n.install(ComicRack)
      
      # see if we're in a valid environment
      if __validate_environment():
         delegate()
         
   except Exception, ex:
      log.handle_error(ex)

 def receive_resources(self, resources):
     """
     add the resources to the village
     create a new object resources with this values and return it
     """
     max_resources = self.max_resources_storage()
     transfered_resources = Resources(
         food=min(
             resources.food,
             max_resources.food - int(self.resources.food),
             ),
         wood=min(
             resources.wood,
             max_resources.wood - int(self.resources.wood),
             ),
         silex=min(
             resources.silex,
             max_resources.silex - int(self.resources.silex),
             ),
         skin=min(
             resources.skin,
             max_resources.skin - int(self.resources.skin),
             ),
     )
     #need to create a new instance of resources to remember for the report
     transfered_resources.pk = None
     transfered_resources.save()
     self.resources += transfered_resources
     self.resources.save()
     self.plan_next_starvation()
     return transfered_resources

    def create_tribe(name, user, carte):
        """
        Initialise une tribe (à utiliser après la création d'un compte)

        """
        tribe = Tribe(name=name, leader=user)
        tribe.save()

        resources_initiales = Resources(
                wood=INIT_TRIBE_RESOURCES['wood'],
                food=INIT_TRIBE_RESOURCES['food'],
                silex=INIT_TRIBE_RESOURCES['silex'],
                skin=INIT_TRIBE_RESOURCES['skin']
                )

        resources_initiales.save()
        village = Village.create_village(tribe, first=True)

        inhabitants = Group.objects.create(
                position=village.position,
                village=village,
                )
        village.inhabitants = inhabitants
        for key in INIT_TRIBE_UNITS:
            new_pile = UnitStack(
                    unit_type=UnitType.objects.get(identifier__iexact=key),
                    group=inhabitants,
                    number=INIT_TRIBE_UNITS[key],
                    )
            new_pile.save()
        village.update_income()

        return tribe

   def __init__(self):
      ''' Creates a _PictureBoxPanel.  Call set_image after initialization. '''
      
      # the left and right arrow Image objects
      self.__left_arrow = Resources.createArrowIcon(True, False)
      self.__full_left_arrow = Resources.createArrowIcon(True, True)
      self.__right_arrow = Resources.createArrowIcon(False, False)
      self.__full_right_arrow = Resources.createArrowIcon(False, True)
      
      # the vertical line boundary between the full_left and left arrow's
      # 'clickable columns' and the full_right and right arrow's.
      self.__left_bound = 0;
      self.__right_bound = 0;

      # the image attributes to use for drawing non-alpha blended images      
      self.__hovered_image_atts = None
      
      # the image attributes to use for drawing alpha blended images      
      self.__normal_image_atts = None
      
      # a string indicating whether the mouse is hovered over the full 
      # left ('FL'), left ('L'), right ('R'), or full right ('FR') side of 
      # this panel, or None if the mouse isn't over the panel at all.  
      self.__mouse_hovered_state = None
      
      # our PictureBox object, which we center and stretch as needed 
      self._picbox = None
      
      Panel.__init__(self)
      self.__build_gui()

def select_oldest(cloud, args):
    if cloud and args is not None:
        resources = Resources(cloud)
        age_resources = SelectAgeRelatedResources(cloud)
        age_resources.select_old_instances(
            datetime.timedelta(hours=args.old_active),
            datetime.timedelta(hours=args.old_inactive),
            datetime.timedelta(days=args.old_permanent),
            datetime.timedelta(hours=args.old_inerrror)
        )
        old_resources = age_resources.get_selection()
        new_search_prefix = None
        oldest = None
        if 'instances' in old_resources:
            for instance in old_resources['instances']:
                rec = old_resources['instances'][instance]
                if rec is None:
                    continue
                if oldest is None or oldest > rec['created_on']:
                    oldest = rec['created_on']
                    new_search_prefix = rec['name']
                logging.info('Found Old instance [{}] created on [{}] age [{}]'
                             .format(rec['name'],
                                     rec['created_on'],
                                     str(rec['age'])))

        if oldest is not None:
            substring = get_substr_from_name(new_search_prefix)
            resources.select_resources(substring)
        return resources
    return None

class PlannerFrame(wx.Frame):
      def __init__(self, parent, id=wx.ID_ANY, title="", pos = wx.DefaultPosition, size = wx.DefaultSize, style = wx.DEFAULT_FRAME_STYLE, name = "PlannerFrame"):
            super(PlannerFrame, self).__init__(parent, id, title, pos, size, style, name)
            self._parent = parent
            self._title = title
            self._resources = Resources(_plannerDataDir+_ResourcesFileName)
            self._fundingSources = FundingSources(_plannerDataDir+_FundingSourcesFileName)
            self._allocations = AllocationSet(_plannerDataDir+_Allocations)

# Create MenuBar
            menuBar = wx.MenuBar()

# Create File Menu
            fileMenu = wx.Menu()
            menuExit = fileMenu.Append(wx.ID_EXIT, "E&xit"," Terminate the program")
            menuSave = fileMenu.Append(wx.ID_SAVE, "&Save", "Save Resources and Funding Sources")
            fileMenu.AppendSeparator()


# Create View Menu
            viewMenu = wx.Menu()

            PLN_RESOURCES = wx.NewId()
            PLN_FUNDINGSOURCES = wx.NewId()
            
            menuResources = viewMenu.Append(PLN_RESOURCES, "&Resources", "Bring up Resources Panel")
            menuFundingSources = viewMenu.Append(PLN_FUNDINGSOURCES, "F&unding Sources", "Bring up Funding Sources Panel")

            menuBar.Append(fileMenu, "&File")
            menuBar.Append(viewMenu, "&View")
            
            self.SetMenuBar(menuBar)
            self.CreateStatusBar()

# File Menu Items
            self.Bind(wx.EVT_MENU, self.OnExit, menuExit)
            self.Bind(wx.EVT_MENU, self.OnSave, menuSave)

# View Menu Items            
            self.Bind(wx.EVT_MENU, self.OnResources, menuResources)
            self.Bind(wx.EVT_MENU, self.OnFundingSources, menuFundingSources)
            
            self.Show(True)

      def OnExit(self, e):
            sys.exit()

      def OnSave(self, e):
            self._resources.write()
            print "Resources Saved"
            self._fundingSources.write()
            print "Funding Sources Saved"
            
      def OnResources(self, e):
            self._resourcesWindow = SelectionListbox(self, self._resources)

      def OnFundingSources(self, e):
            self._fundingSourcesWindow = SelectionListbox(self, self._fundingSources)

    def updateEncryptionLock(self, msgid, encryption=None):
        if encryption is None:
            return

        if encryption == '':
            lock_icon_path = Resources.get('unlocked-darkgray.png')
        else:
            lock_icon_path = Resources.get('locked-green.png' if encryption == 'verified' else 'locked-red.png')
        script = "updateEncryptionLock('%s','%s')" % (msgid, lock_icon_path)
        self.executeJavaScript(script)

 def __init__(self, window):
     QWebView.__init__(self)
     self.window = window
     with open(Resources.get_path("leftpane.js"), "r") as f:
         self.js = f.read()
     self.setFixedWidth(0)
     self.setVisible(False)
     # We don't want plugins for this simple pane
     self.settings().setAttribute(QWebSettings.PluginsEnabled, False)
     self.setUrl(QUrl.fromLocalFile(Resources.get_path("leftpane.html")))
     self.page().currentFrame().addToJavaScriptWindowObject("leftPane", self)
     self.page().currentFrame().evaluateJavaScript(self.js)

 def word_sim(self, w1, w2, simtype):
     if (w1, w2) in AlignAndPenalize.word_cache:
         return AlignAndPenalize.word_cache[(w1, w2)]
     # context-free similarity
     if w1 == w2 or Resources.is_num_equivalent(w1, w2) or Resources.is_pronoun_equivalent(w1, w2):
         AlignAndPenalize.word_cache[(w1, w2)] = 1
         AlignAndPenalize.word_cache[(w2, w1)] = 1
         return 1
     sim = self.similarities[simtype].word_sim(w1, w2)
     if sim is None and self.fallback_similarity:
         sim = self.fallback_similarity.word_sim(w1, w2)
     elif sim is None:
         sim = 0.0
     return sim

 def __init__(self, parent = None, settings_path = ""):
     super(ScudCloud, self).__init__(parent)
     self.setWindowTitle('ScudCloud')
     self.settings_path = settings_path
     self.notifier = Notifier(Resources.APP_NAME, Resources.get_path('scudcloud.png'))
     self.settings = QSettings(self.settings_path + '/scudcloud.cfg', QSettings.IniFormat)
     self.identifier = self.settings.value("Domain")
     if Unity is not None:
         self.launcher = Unity.LauncherEntry.get_for_desktop_id("scudcloud.desktop")
     else:
         self.launcher = DummyLauncher(self)
     self.webSettings()
     self.leftPane = LeftPane(self)
     self.stackedWidget = QtGui.QStackedWidget()
     centralWidget = QtGui.QWidget(self)
     layout = QtGui.QHBoxLayout()
     layout.setContentsMargins(0, 0, 0, 0)
     layout.setSpacing(0)
     layout.addWidget(self.leftPane)
     layout.addWidget(self.stackedWidget)
     centralWidget.setLayout(layout)
     self.setCentralWidget(centralWidget)
     self.startURL = Resources.SIGNIN_URL
     if self.identifier is not None:
         self.startURL = self.domain()
     self.addWrapper(self.startURL)
     self.addMenu()
     self.tray = Systray(self)
     self.systray(ScudCloud.minimized)
     self.installEventFilter(self)
     self.statusBar().showMessage('Loading Slack...')

 def set_image(self, image):
    '''
    Sets a new image for this _PictureBoxPanel to display.   If this image is
    None, a default logo will be displayed.  Any previous image that was set
    will have its Dispose() method called before it is discarded.
    '''
    
    if not image:
       image = Resources.createComicVineLogo()
    
    self._ratio = 0;
    if image and float(image.Height):
       self._ratio = float(image.Width) / float(image.Height)
    if not self._ratio:
       self._ratio =1.55
       
    # dispose the old image, if need be
    if self._picbox.Image:
       self._picbox.Image.Dispose()
       
    self._picbox.Image = image
    self.OnResize(None)
    
    # update our mouse cursor
    comicform = self.Parent
    if comicform != None:
       self.Cursor = Cursors.Hand if comicform._can_change_page(True) or \
         comicform._can_change_page(False) else None

    def __init__(self, title, resources=None, other=None):
        self.title = title
        self.parent = None

        if resources is None:
            self.resources = Resources()
        else:
            self.resources = resources

        self.other = other

        self.wid_delete_btn = widgets.Button(description='Delete', margin="8px")
        self.wid_delete_btn._gem_ctx = self

        def yes_cb(model):
            parent = model.parent_get()
            parent.model_del(model)

        def no_cb(model):
            return

        def model_delete_cb(model_delete_cb):
            metys_confirm("Delete '%s' model, confirm it ?" % self.title, yes_cb, no_cb, self)
            return

        self.wid_delete_btn.on_click(model_delete_cb)
        wid_label = widgets.Label(value="Model:")
        self.widget = widgets.VBox(children=[
            self.resources.widget_get(), wid_label, self.wid_delete_btn])

 def __init__(self, parent = None, settings_path = ""):
     super(zcswebapp, self).__init__(parent)
     self.setWindowTitle('zcswebapp')
     self.settings_path = settings_path
     self.notifier = Notifier(Resources.APP_NAME, Resources.get_path('zcswebapp.png'))
     self.settings = QSettings(self.settings_path + '/zcswebapp.cfg', QSettings.IniFormat)
     self.identifier = self.settings.value("Domain")
     if Unity is not None:
         self.launcher = Unity.LauncherEntry.get_for_desktop_id("zcswebapp.desktop")
     else:
         self.launcher = DummyLauncher(self)
     self.webSettings()
     self.leftPane = LeftPane(self)
     webView = Wrapper(self)
     webView.page().networkAccessManager().setCookieJar(self.cookiesjar)
     self.stackedWidget = QtGui.QStackedWidget()
     self.stackedWidget.addWidget(webView)
     centralWidget = QtGui.QWidget(self)
     layout = QtGui.QHBoxLayout()
     layout.setContentsMargins(0, 0, 0, 0)
     layout.setSpacing(0)
     layout.addWidget(self.leftPane)
     layout.addWidget(self.stackedWidget)
     centralWidget.setLayout(layout)
     self.setCentralWidget(centralWidget)
     self.addMenu()
     self.tray = Systray(self)
     self.systray(zcswebapp.minimized)
     self.installEventFilter(self)
     if self.identifier is None:
         webView.load(QtCore.QUrl(Resources.SIGNIN_URL))
     else:
         webView.load(QtCore.QUrl(self.domain()))
     webView.show()

 def achieve_mission_found(self):
     if not self.group.resources or\
             self.group.position.village_set.count() >= NB_VILLAGES_PER_TILE\
             or self.group.resources <\
             Resources.dict_to_resources(VILLAGE_CREATION_NEEDED_RESOURCES):
         self.come_back()
         self.group.log_report(
                 type=11,
                 subject='Impossible de créer le village',
                 body='Tous les emplacements de la case'
                     ' sélectionnée sont occupés ou bien '
                     'vous ne disposez pas de suffisamment de ressources',
                 )
     v = Village(
             name="New village",
             inhabitants=self.group,
             resources=Resources.objects.create(),
             tribe=self.group.village.tribe,
             position=self.group.position,
             )
     v.resources.save()
     v.save()
     v.update_income()
     self.group.village = v
     self.group.save()
     update_resources = v.receive_resources(self.group.resources)
     update_resources.save()
     self.group.resources = update_resources
     self.group.resources -= v.receive_resources(self.group.ressources)
     self.group.resources.save()

 def __init__(self, window):
     QWebView.__init__(self)
     self.window = window
     with open(Resources.get_path("leftpane.js"), "r") as f:
         self.js = f.read()
     # We don't want plugins for this simple pane
     self.settings().setAttribute(QWebSettings.PluginsEnabled, False)
     self.reset()

 def calcadjvals(self):
   self.setadjpoints()
   adjvals = []
   if self.scentview:
     for point in self.adjpoints:
       shortestdist = Resources.calcdistance(point, self.scentview[0].rect.center)
       normalizeddist = shortestdist/(self.current_scent_dist * math.sqrt(2))
       adjvals.append(1 - normalizeddist)
   return adjvals

 def __init__(self, window):
     self.configure_proxy()
     QWebView.__init__(self)
     self.window = window
     with open(Resources.get_path("scudcloud.js"), "r") as f:
         self.js = f.read()
     self.setZoomFactor(self.window.zoom)
     self.page().setLinkDelegationPolicy(QtWebKit.QWebPage.DelegateAllLinks)
     self.connect(self, SIGNAL("urlChanged(const QUrl&)"), self.urlChanged)
     self.connect(self, SIGNAL("linkClicked(const QUrl&)"), self.linkClicked)
     self.addActions()

    def play_hangup(self):
        settings = SIPSimpleSettings()

        if settings.audio.silent:
            return

        if time.time() - self.last_hangup_tone_time > HANGUP_TONE_THROTLE_DELAY:
            hangup_tone = WavePlayer(SIPApplication.voice_audio_mixer, Resources.get('hangup_tone.wav'), volume=30)
            NotificationCenter().add_observer(self, sender=hangup_tone, name="WavePlayerDidEnd")
            SIPApplication.voice_audio_bridge.add(hangup_tone)
            hangup_tone.start()
            self.last_hangup_tone_time = time.time()

 def urlChanged(self, qUrl):
     url = qUrl.toString()
     # Some integrations/auth will get back to /services with no way to get back to chat
     if Resources.SERVICES_URL_RE.match(url):
         self.systemOpen(url)
         self.load(QUrl("https://"+qUrl.host()+"/messages/general"))
     else:
         self.settings().setUserStyleSheetUrl(QUrl.fromLocalFile(Resources.get_path("login.css")))
         self.inject()
         # Save the loading team as default
         if url.endswith("/messages"):
             self.window.settings.setValue("Domain", 'https://'+qUrl.host())

 def filter_tokens(self, tokens):
     new_tok = []
     for token in tokens:
         word = token['token']
         if self.conf.getboolean('global', 'remove_stopwords') and word in Resources.stopwords:
             continue
         if self.conf.getboolean('global', 'remove_punctuation') and word in Resources.punctuation:
             continue
         if self.conf.getboolean('global', 'filter_frequent_adverbs') and Resources.is_frequent_adverb(word, token['pos']):
             continue
         new_tok.append(token)
     return new_tok