Changeset 1076:5a7bb93c337d for src/mlx


Ignore:
Timestamp:
02/14/23 14:30:51 (22 months ago)
Author:
István Váradi <ivaradi@…>
Branch:
python3
Phase:
public
Message:

SimBrief handling is reworked to use the user's browser (re #362)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/mlx/gui/flight.py

    r1075 r1076  
    2525import re
    2626import webbrowser
     27import urllib.request, urllib.error, urllib.parse
     28from lxml import etree
     29from io import StringIO
     30import lxml.html
     31import certifi
    2732
    2833#-----------------------------------------------------------------------------
    … …  
    32073212        }
    32083213
     3214    _resultQueryInterval = 2000
     3215
     3216    _waitTimeout = 2 * 60.0
     3217
    32093218    @staticmethod
    32103219    def getHTMLFilePath():
    … …  
    32343243                                  xscale = 0.0, yscale = 0.0)
    32353244
    3236         table = Gtk.Table(9, 3)
     3245        table = Gtk.Table(6, 3)
    32373246        table.set_row_spacings(4)
    32383247        table.set_col_spacings(16)
    … …  
    32413250        self.setMainWidget(alignment)
    32423251
    3243         label = Gtk.Label(xstr("simbrief_username"))
    3244         label.set_use_underline(True)
    3245         label.set_alignment(0.0, 0.5)
    3246         table.attach(label, 0, 1, 0, 1)
    3247 
    3248         self._userName = Gtk.Entry()
    3249         self._userName.set_width_chars(16)
    3250         self._userName.connect("changed",
    3251                                lambda button: self._updateForwardButton())
    3252         self._userName.set_tooltip_text(xstr("simbrief_username_tooltip"))
    3253         table.attach(self._userName, 1, 2, 0, 1)
    3254         label.set_mnemonic_widget(self._userName)
    3255 
    3256         label = Gtk.Label(xstr("simbrief_password"))
    3257         label.set_use_underline(True)
    3258         label.set_alignment(0.0, 0.5)
    3259         table.attach(label, 0, 1, 1, 2)
    3260 
    3261         self._password = Gtk.Entry()
    3262         self._password.set_visibility(False)
    3263         self._password.connect("changed",
    3264                                lambda button: self._updateForwardButton())
    3265         self._password.set_tooltip_text(xstr("simbrief_password_tooltip"))
    3266         table.attach(self._password, 1, 2, 1, 2)
    3267         label.set_mnemonic_widget(self._password)
    3268 
    3269         self._rememberButton = Gtk.CheckButton(xstr("simbrief_remember_password"))
    3270         self._rememberButton.set_use_underline(True)
    3271         self._rememberButton.set_tooltip_text(xstr("simbrief_remember_tooltip"))
    3272         table.attach(self._rememberButton, 1, 2, 2, 3, ypadding = 8)
     3252
     3253        row = 0
     3254
     3255        # label = Gtk.Label(xstr("simbrief_username"))
     3256        # label.set_use_underline(True)
     3257        # label.set_alignment(0.0, 0.5)
     3258        # table.attach(label, 0, 1, row, row+1)
     3259
     3260        # self._userName = Gtk.Entry()
     3261        # self._userName.set_width_chars(16)
     3262        # self._userName.connect("changed",
     3263        #                        lambda button: self._updateForwardButton())
     3264        # self._userName.set_tooltip_text(xstr("simbrief_username_tooltip"))
     3265        # table.attach(self._userName, 1, 2, row, row+1)
     3266        # label.set_mnemonic_widget(self._userName)
     3267        # row += 1
     3268
     3269        # label = Gtk.Label(xstr("simbrief_password"))
     3270        # label.set_use_underline(True)
     3271        # label.set_alignment(0.0, 0.5)
     3272        # table.attach(label, 0, 1, row, row+1)
     3273
     3274        # self._password = Gtk.Entry()
     3275        # self._password.set_visibility(False)
     3276        # self._password.connect("changed",
     3277        #                        lambda button: self._updateForwardButton())
     3278        # self._password.set_tooltip_text(xstr("simbrief_password_tooltip"))
     3279        # table.attach(self._password, 1, 2, row, row+1)
     3280        # label.set_mnemonic_widget(self._password)
     3281        # row += 1
     3282
     3283        # self._rememberButton = Gtk.CheckButton(xstr("simbrief_remember_password"))
     3284        # self._rememberButton.set_use_underline(True)
     3285        # self._rememberButton.set_tooltip_text(xstr("simbrief_remember_tooltip"))
     3286        # table.attach(self._rememberButton, 1, 2, row, row+1, ypadding = 8)
     3287        # row += 1
    32733288
    32743289        label = Gtk.Label(xstr("simbrief_extra_fuel"))
    32753290        label.set_use_underline(True)
    32763291        label.set_alignment(0.0, 0.5)
    3277         table.attach(label, 0, 1, 3, 4)
     3292        table.attach(label, 0, 1, row, row+1)
    32783293
    32793294        self._extraFuel = IntegerEntry(defaultValue = 0)
    32803295        self._extraFuel.set_width_chars(6)
    32813296        self._extraFuel.set_tooltip_text(xstr("simbrief_extra_fuel_tooltip"))
    3282         table.attach(self._extraFuel, 1, 2, 3, 4)
     3297        table.attach(self._extraFuel, 1, 2, row, row+1)
    32833298        label.set_mnemonic_widget(self._extraFuel)
    32843299
    3285         table.attach(Gtk.Label("kg"), 2, 3, 3, 4)
     3300        table.attach(Gtk.Label("kg"), 2, 3, row, row+1)
     3301        row += 1
    32863302
    32873303        label = Gtk.Label(xstr("simbrief_takeoff_runway"))
    32883304        label.set_use_underline(True)
    32893305        label.set_alignment(0.0, 0.5)
    3290         table.attach(label, 0, 1, 4, 5)
     3306        table.attach(label, 0, 1, row, row+1)
    32913307
    32923308        self._takeoffRunway = Gtk.Entry()
    … …  
    32943310        self._takeoffRunway.set_tooltip_text(xstr("simbrief_takeoff_runway_tooltip"))
    32953311        self._takeoffRunway.connect("changed", self._upperChanged)
    3296         table.attach(self._takeoffRunway, 1, 2, 4, 5)
     3312        table.attach(self._takeoffRunway, 1, 2, row, row+1)
    32973313        label.set_mnemonic_widget(self._takeoffRunway)
     3314        row += 1
    32983315
    32993316        label = Gtk.Label(xstr("simbrief_landing_runway"))
    33003317        label.set_use_underline(True)
    33013318        label.set_alignment(0.0, 0.5)
    3302         table.attach(label, 0, 1, 5, 6)
     3319        table.attach(label, 0, 1, row, row+1)
    33033320
    33043321        self._landingRunway = Gtk.Entry()
    33053322        self._landingRunway.set_width_chars(10)
    3306         self._landingRunway.set_tooltip_text(xstr("simbrief_takeoff_runway_tooltip"))
     3323        self._landingRunway.set_tooltip_text(xstr("simbrief_landing_runway_tooltip"))
    33073324        self._landingRunway.connect("changed", self._upperChanged)
    3308         table.attach(self._landingRunway, 1, 2, 5, 6)
     3325        table.attach(self._landingRunway, 1, 2, row, row+1)
    33093326        label.set_mnemonic_widget(self._landingRunway)
     3327        row += 1
    33103328
    33113329        label = Gtk.Label(xstr("simbrief_climb_profile"))
    33123330        label.set_use_underline(True)
    33133331        label.set_alignment(0.0, 0.5)
    3314         table.attach(label, 0, 1, 6, 7)
     3332        table.attach(label, 0, 1, row, row+1)
    33153333
    33163334        self._climbProfile = Gtk.ComboBox()
    … …  
    33193337        self._climbProfile.add_attribute(renderer, "text", 0)
    33203338        self._climbProfile.set_tooltip_text(xstr("simbrief_climb_profile_tooltip"))
    3321         table.attach(self._climbProfile, 1, 2, 6, 7)
     3339        table.attach(self._climbProfile, 1, 2, row, row+1)
    33223340        label.set_mnemonic_widget(self._climbProfile)
     3341        row += 1
    33233342
    33243343        label = Gtk.Label(xstr("simbrief_cruise_profile"))
    33253344        label.set_use_underline(True)
    33263345        label.set_alignment(0.0, 0.5)
    3327         table.attach(label, 0, 1, 7, 8)
     3346        table.attach(label, 0, 1, row, row+1)
    33283347
    33293348        self._cruiseProfile = Gtk.ComboBox()
    … …  
    33323351        self._cruiseProfile.add_attribute(renderer, "text", 0)
    33333352        self._cruiseProfile.set_tooltip_text(xstr("simbrief_cruise_profile_tooltip"))
    3334         table.attach(self._cruiseProfile, 1, 2, 7, 8)
     3353        table.attach(self._cruiseProfile, 1, 2, row, row+1)
    33353354        label.set_mnemonic_widget(self._cruiseProfile)
     3355        row += 1
    33363356
    33373357        label = Gtk.Label(xstr("simbrief_descent_profile"))
    33383358        label.set_use_underline(True)
    33393359        label.set_alignment(0.0, 0.5)
    3340         table.attach(label, 0, 1, 8, 9)
     3360        table.attach(label, 0, 1, row, row+1)
    33413361
    33423362        self._descentProfile = Gtk.ComboBox()
    … …  
    33453365        self._descentProfile.add_attribute(renderer, "text", 0)
    33463366        self._descentProfile.set_tooltip_text(xstr("simbrief_descent_profile_tooltip"))
    3347         table.attach(self._descentProfile, 1, 2, 8, 9)
     3367        table.attach(self._descentProfile, 1, 2, row, row+1)
    33483368        label.set_mnemonic_widget(self._descentProfile)
    33493369
    … …  
    33523372        self._backButton = self.addPreviousButton(clicked = self._backClicked)
    33533373        self._button = self.addNextButton(clicked = self._forwardClicked)
     3374
     3375        self._resultTimestamp = None
    33543376
    33553377    def activate(self):
    … …  
    33573379        config = self._wizard.gui.config
    33583380
    3359         self._userName.set_text(config.simBriefUserName)
    3360         self._userName.set_sensitive(True)
    3361 
    3362         self._password.set_text(config.simBriefPassword)
    3363         self._password.set_sensitive(True)
    3364 
    3365         self._rememberButton.set_active(config.rememberSimBriefPassword)
    3366         self._rememberButton.set_sensitive(True)
     3381        # self._userName.set_text(config.simBriefUserName)
     3382        # self._userName.set_sensitive(True)
     3383
     3384        # self._password.set_text(config.simBriefPassword)
     3385        # self._password.set_sensitive(True)
     3386
     3387        # self._rememberButton.set_active(config.rememberSimBriefPassword)
     3388        # self._rememberButton.set_sensitive(True)
    33673389
    33683390        self._extraFuel.set_int(0)
    … …  
    33923414        self._descentProfile.set_active(0)
    33933415
     3416        self._resultTimestamp = None
     3417        self._waitEnd = None
     3418
    33943419        self._updateForwardButton()
    33953420
    33963421    def _updateForwardButton(self):
    33973422        """Update the sensitivity of the forward button."""
    3398         self._button.set_sensitive(len(self._userName.get_text())>0 and
    3399                                    len(self._password.get_text())>0)
     3423        self._button.set_sensitive(True)
     3424        # self._button.set_sensitive(len(self._userName.get_text())>0 and
     3425        #                            len(self._password.get_text())>0)
    34003426
    34013427    def _backClicked(self, button):
    … …  
    34073433            self._wizard.nextPage()
    34083434        else:
    3409             config = self._wizard.gui.config
    3410 
    3411             config.simBriefUserName = self._userName.get_text()
    3412 
    3413             rememberPassword = self._rememberButton.get_active()
    3414             config.simBriefPassword = \
    3415               self._password.get_text() if rememberPassword else ""
    3416             config.rememberSimBriefPassword = rememberPassword
    3417 
    3418             config.save()
    3419 
    3420             plan = self._getPlan()
    3421             print("plan:", plan)
    3422 
    3423             takeoffRunway = self._takeoffRunway.get_text()
    3424             if takeoffRunway:
    3425                 self._wizard.takeoffRunway = takeoffRunway
    3426 
    3427             landingRunway = self._landingRunway.get_text()
    3428             if landingRunway:
    3429                 self._wizard.landingRunway = landingRunway
    3430 
    3431             self._userName.set_sensitive(False)
    3432             self._password.set_sensitive(False)
    3433             self._rememberButton.set_sensitive(False)
    3434             self._extraFuel.set_sensitive(False)
    3435             self._takeoffRunway.set_sensitive(False)
    3436             self._landingRunway.set_sensitive(False)
    3437 
    3438             self._climbProfile.set_sensitive(False)
    3439             self._cruiseProfile.set_sensitive(False)
    3440             self._descentProfile.set_sensitive(False)
    3441 
    3442             self._wizard.gui.beginBusy(xstr("simbrief_calling"))
    3443 
    3444             cef.callSimBrief(plan,
    3445                              self._getCredentials,
    3446                              self._simBriefProgress,
    3447                              SimBriefSetupPage.getHTMLFilePath())
    3448 
    3449             startSound(const.SOUND_NOTAM)
    3450 
    3451     def _getCredentials(self, count):
    3452         """Get the credentials.
    3453 
    3454         If count is 0, the user name and password entered into the setup page
    3455         are returned. Otherwise a dialog box is displayed informing the user of
    3456         invalid credentials and requesting another set of them."""
    3457         print("_getCredentials", count)
    3458         if count==0:
    3459             return (self._userName.get_text(), self._password.get_text())
    3460         else:
    3461             gui = self._wizard.gui
    3462             config = gui.config
    3463 
    3464             dialog = SimBriefCredentialsDialog(gui,
    3465                                                config.simBriefUserName,
    3466                                                config.simBriefPassword,
    3467                                                config.rememberSimBriefPassword)
    3468             response = dialog.run()
    3469 
    3470             if response==Gtk.ResponseType.OK:
    3471                 userName = dialog.userName
    3472                 self._userName.set_text(userName)
    3473                 password = dialog.password
    3474                 self._password.set_text(password)
    3475                 rememberPassword = dialog.rememberPassword
    3476 
    3477                 config.simBriefUserName = userName
    3478 
    3479                 config.simBriefPassword = \
    3480                     password if rememberPassword else ""
    3481                 config.rememberSimBriefPassword = rememberPassword
    3482 
    3483                 config.save()
    3484 
    3485                 return (userName, password)
    3486             else:
    3487                 return (None, None)
    3488 
    3489     def _simBriefProgress(self, progress, result, flightInfo):
    3490         """The real SimBrief progress handler."""
    3491         print("_simBriefProgress", progress, result, flightInfo)
    3492         if result==cef.SIMBRIEF_RESULT_NONE:
    3493             message = SimBriefSetupPage.progress2Message.get(progress,
    3494                                                              "simbrief_progress_unknown")
    3495             self._wizard.gui.updateBusyState(xstr(message))
    3496         else:
    3497             self._wizard.gui.endBusy()
    3498 
    3499             if result==cef.SIMBRIEF_RESULT_OK:
    3500                 self._wizard.departureMETARChanged(flightInfo["orig_metar"],
    3501                                                    self)
    3502                 self._wizard.arrivalMETARChanged(flightInfo["dest_metar"], self)
    3503                 self._wizard.nextPage()
    3504             else:
    3505                 message = SimBriefSetupPage.result2Message.get(result,
    3506                                                                "simbrief_result_unknown")
    3507                 dialog = Gtk.MessageDialog(parent = self._wizard.gui.mainWindow,
    3508                                            type = Gtk.MessageType.ERROR,
    3509                                            message_format =
    3510                                            xstr(message) + "\n"+
    3511                                            xstr("simbrief_cancelled"))
    3512 
    3513                 dialog.add_button(xstr("button_ok"), Gtk.ResponseType.OK)
    3514                 dialog.set_title(WINDOW_TITLE_BASE)
    3515                 secondary = xstr("flightsel_save_failed_sec")
    3516                 dialog.format_secondary_markup(secondary)
    3517                 dialog.run()
    3518                 dialog.hide()
    3519 
    3520                 self._wizard.usingSimBrief = False
    3521                 self._wizard.jumpPage("fuel", fromPageShift = 1)
    3522 
    3523     def _getPlan(self):
     3435            # config = self._wizard.gui.config
     3436
     3437            # config.simBriefUserName = self._userName.get_text()
     3438
     3439            # rememberPassword = self._rememberButton.get_active()
     3440            # config.simBriefPassword = \
     3441            #   self._password.get_text() if rememberPassword else ""
     3442            # config.rememberSimBriefPassword = rememberPassword
     3443
     3444            # config.save()
     3445
     3446            self._wizard.gui.simulator.requestTime(self._handleTime)
     3447
     3448    def _handleTime(self, simulatorNow):
     3449        """Handle the result of a time retrieval."""
     3450        GObject.idle_add(self._processTime, simulatorNow)
     3451
     3452    def _processTime(self, simulatorNow):
     3453        """Process the given time."""
     3454        plan = self._getPlan(simulatorNow)
     3455        print("plan:", plan)
     3456
     3457        takeoffRunway = self._takeoffRunway.get_text()
     3458        if takeoffRunway:
     3459            self._wizard.takeoffRunway = takeoffRunway
     3460
     3461        landingRunway = self._landingRunway.get_text()
     3462        if landingRunway:
     3463            self._wizard.landingRunway = landingRunway
     3464
     3465        # self._userName.set_sensitive(False)
     3466        # self._password.set_sensitive(False)
     3467        # self._rememberButton.set_sensitive(False)
     3468        self._extraFuel.set_sensitive(False)
     3469        self._takeoffRunway.set_sensitive(False)
     3470        self._landingRunway.set_sensitive(False)
     3471
     3472        self._climbProfile.set_sensitive(False)
     3473        self._cruiseProfile.set_sensitive(False)
     3474        self._descentProfile.set_sensitive(False)
     3475
     3476        self._wizard.gui.beginBusy(xstr("simbrief_calling"))
     3477
     3478        url = MAVA_BASE_URL + "/simbrief_form.php?" + \
     3479            urllib.parse.urlencode(plan)
     3480        print("url:", url)
     3481
     3482        # GObject.idle_add(self._resultsAvailable,
     3483        #                  { "orig_metar": "LDZA...",
     3484        #                    "dest_metar": "LHBP..." })
     3485        # return
     3486
     3487        webbrowser.open(url = url, new = 1)
     3488
     3489        # cef.callSimBrief(plan,
     3490        #                  self._getCredentials,
     3491        #                  self._simBriefProgress,
     3492        #                 SimBriefSetupPage.getHTMLFilePath())
     3493
     3494        startSound(const.SOUND_NOTAM)
     3495
     3496        self._waitEnd = time.time() + SimBriefSetupPage._waitTimeout
     3497        GObject.timeout_add(SimBriefSetupPage._resultQueryInterval,
     3498                            lambda: self._wizard.gui.webHandler. \
     3499                            getSimBriefResult(self._resultCallback,
     3500                                              self._resultTimestamp))
     3501
     3502    # def _getCredentials(self, count):
     3503    #     """Get the credentials.
     3504
     3505    #     If count is 0, the user name and password entered into the setup page
     3506    #     are returned. Otherwise a dialog box is displayed informing the user of
     3507    #     invalid credentials and requesting another set of them."""
     3508    #     print("_getCredentials", count)
     3509    #     if count==0:
     3510    #         return (self._userName.get_text(), self._password.get_text())
     3511    #     else:
     3512    #         gui = self._wizard.gui
     3513    #         config = gui.config
     3514
     3515    #         dialog = SimBriefCredentialsDialog(gui,
     3516    #                                            config.simBriefUserName,
     3517    #                                            config.simBriefPassword,
     3518    #                                            config.rememberSimBriefPassword)
     3519    #         response = dialog.run()
     3520
     3521    #         if response==Gtk.ResponseType.OK:
     3522    #             userName = dialog.userName
     3523    #             self._userName.set_text(userName)
     3524    #             password = dialog.password
     3525    #             self._password.set_text(password)
     3526    #             rememberPassword = dialog.rememberPassword
     3527
     3528    #             config.simBriefUserName = userName
     3529
     3530    #             config.simBriefPassword = \
     3531    #                 password if rememberPassword else ""
     3532    #             config.rememberSimBriefPassword = rememberPassword
     3533
     3534    #             config.save()
     3535
     3536    #             return (userName, password)
     3537    #         else:
     3538    #             return (None, None)
     3539
     3540    # def _simBriefProgress(self, progress, result, flightInfo):
     3541    #     """The real SimBrief progress handler."""
     3542    #     print("_simBriefProgress", progress, result, flightInfo)
     3543    #     if result==cef.SIMBRIEF_RESULT_NONE:
     3544    #         message = SimBriefSetupPage.progress2Message.get(progress,
     3545    #                                                          "simbrief_progress_unknown")
     3546    #         self._wizard.gui.updateBusyState(xstr(message))
     3547    #     else:
     3548    #         self._wizard.gui.endBusy()
     3549
     3550    #         if result==cef.SIMBRIEF_RESULT_OK:
     3551    #             self._wizard.departureMETARChanged(flightInfo["orig_metar"],
     3552    #                                                self)
     3553    #             self._wizard.arrivalMETARChanged(flightInfo["dest_metar"], self)
     3554    #             self._wizard.nextPage()
     3555    #         else:
     3556    #             message = SimBriefSetupPage.result2Message.get(result,
     3557    #                                                            "simbrief_result_unknown")
     3558    #             dialog = Gtk.MessageDialog(parent = self._wizard.gui.mainWindow,
     3559    #                                        type = Gtk.MessageType.ERROR,
     3560    #                                        message_format =
     3561    #                                        xstr(message) + "\n"+
     3562    #                                        xstr("simbrief_cancelled"))
     3563
     3564    #             dialog.add_button(xstr("button_ok"), Gtk.ResponseType.OK)
     3565    #             dialog.set_title(WINDOW_TITLE_BASE)
     3566    #             secondary = xstr("flightsel_save_failed_sec")
     3567    #             dialog.format_secondary_markup(secondary)
     3568    #             dialog.run()
     3569    #             dialog.hide()
     3570
     3571    #             self._wizard.usingSimBrief = False
     3572    #             self._wizard.jumpPage("fuel", fromPageShift = 1)
     3573
     3574    def _getPlan(self, simulatorNow):
    35243575        """Get the flight plan data for SimBrief."""
     3576        print("timestamp:", simulatorNow)
     3577
     3578        self._resultTimestamp = now = int(time.time())
     3579
    35253580        plan = {
    35263581            "airline": "MAH",
    … …  
    35313586            "taxiout": "10",
    35323587            "taxiin": "10",
    3533             "civalue": "AUTO"
     3588            "civalue": "AUTO",
     3589            "lang": "hun" if getLanguage().lower()=="hu" else "eng",
     3590            "sessionID": self._wizard._loginResult.sessionID,
     3591            "timestamp": now
    35343592            }
    35353593
    … …  
    35473605        plan["dest"] = bookedFlight.arrivalICAO
    35483606        plan["reg"] = bookedFlight.tailNumber
    3549         plan["fin"] = bookedFlight.tailNumber[3:]
    35503607        plan["pax"] = str(bookedFlight.numPassengers)
    35513608
    35523609        departureTime = bookedFlight.departureTime
    3553         plan["date"] = "%d%s%d" % (departureTime.day,
    3554                                    SimBriefSetupPage.monthNum2Name[departureTime.month-1],
    3555                                    departureTime.year%100)
    3556         plan["deph"] = str(departureTime.hour)
    3557         plan["depm"] = str(departureTime.minute)
     3610        print("departureTime", departureTime)
     3611
     3612        tm = time.gmtime(simulatorNow)
     3613        diffMinutes = (departureTime.hour - tm.tm_hour)*60 + \
     3614            departureTime.minute - tm.tm_min
     3615        while diffMinutes<0:
     3616            diffMinutes += 24*60
     3617
     3618        realDepartureTime = datetime.datetime.utcnow()
     3619        realDepartureTime += datetime.timedelta(minutes = diffMinutes)
     3620
     3621        plan["date"] = "%02d%s%02d" % (realDepartureTime.day,
     3622                                       SimBriefSetupPage.monthNum2Name[realDepartureTime.month-1],
     3623                                       realDepartureTime.year%100)
     3624        plan["deph"] = str(realDepartureTime.hour)
     3625        plan["depm"] = str(realDepartureTime.minute)
    35583626
    35593627        arrivalTime = bookedFlight.arrivalTime
    3560         plan["steh"] = str(arrivalTime.hour)
    3561         plan["stem"] = str(arrivalTime.minute)
     3628        blockMinutes = (arrivalTime.hour - departureTime.hour)*60 + \
     3629            arrivalTime.minute - departureTime.minute
     3630        while blockMinutes<0:
     3631            blockMinutes += 24*60
     3632        plan["steh"] = str(blockMinutes//60)
     3633        plan["stem"] = str(blockMinutes%60)
    35623634
    35633635        plan["manualzfw"] = str(wizard.zfw / 1000.0)
    … …  
    35823654        return plan
    35833655
     3656    def _resultCallback(self, returned, result):
     3657        """Callback for the SimBrief result query."""
     3658        GObject.idle_add(self._handleResult, returned, result)
     3659
     3660    def _handleResult(self, returned, result):
     3661        """Handle an RPC query result."""
     3662        print("_handleResult", returned, result)
     3663        if result.result and result.result.get("result"):
     3664            link = result.result.get("result")
     3665            if link=="<failed>":
     3666                self._wizard.gui.endBusy()
     3667
     3668                self._finishWithError()
     3669            else:
     3670                link ="https://www.simbrief.com/ofp/flightplans/xml/" + link + ".xml"
     3671
     3672                thread = threading.Thread(target = self._getResults, args = (link,))
     3673                thread.daemon = True
     3674                thread.start()
     3675
     3676        elif time.time() >= self._waitEnd:
     3677            self._wizard.gui.endBusy()
     3678
     3679            self._finishWithError()
     3680        else:
     3681            GObject.timeout_add(SimBriefSetupPage._resultQueryInterval,
     3682                                lambda: self._wizard.gui.webHandler. \
     3683                                getSimBriefResult(self._resultCallback,
     3684                                                  self._resultTimestamp))
     3685
    35843686    def _upperChanged(self, entry, arg = None):
    35853687        """Called when the value of some entry widget has changed and the value
    35863688        should be converted to uppercase."""
    35873689        entry.set_text(entry.get_text().upper())
     3690
     3691    def _getResults(self, link):
     3692        """Get the result from the given link."""
     3693        ## Holds analysis data to be used
     3694        flightInfo = {}
     3695        try:
     3696            availableInfo = {}
     3697
     3698            # Obtaining the xml
     3699            response = urllib.request.urlopen(link,
     3700                                              cafile = certifi.where())
     3701            content = etree.iterparse(response)
     3702
     3703            for (action, element) in content:
     3704                # Processing tags that occur multiple times
     3705                if element.tag == "weather":
     3706                    weatherElementList = list(element)
     3707                    for weatherElement in weatherElementList:
     3708                        flightInfo[weatherElement.tag] = weatherElement.text
     3709                else:
     3710                    availableInfo[element.tag] = element.text
     3711
     3712            # Processing plan_html
     3713            ## Obtaining chart links
     3714            imageLinks = []
     3715            for imageLinkElement in lxml.html.find_class(availableInfo["plan_html"],
     3716                                                         "ofpmaplink"):
     3717                for imageLink in imageLinkElement.iterlinks():
     3718                    if imageLink[1] == 'src':
     3719                        imageLinks.append(imageLink[2])
     3720            flightInfo["image_links"] = imageLinks
     3721            print((sorted(availableInfo.keys())))
     3722            htmlFilePath = SimBriefSetupPage.getHTMLFilePath()
     3723            with open(htmlFilePath, 'w') as f:
     3724                f.write(availableInfo["plan_html"])
     3725        except Exception as e:
     3726            print("_getResults", e)
     3727
     3728        GObject.idle_add(self._resultsAvailable, flightInfo)
     3729
     3730    def _resultsAvailable(self, flightInfo):
     3731        """Called from the result retrieval thread when the result is
     3732        available."""
     3733        print("_resultsAvailable")
     3734        self._wizard.gui.endBusy()
     3735
     3736        if flightInfo:
     3737            self._wizard.departureMETARChanged(flightInfo["orig_metar"],
     3738                                               self)
     3739            self._wizard.arrivalMETARChanged(flightInfo["dest_metar"], self)
     3740            self._wizard.nextPage()
     3741        else:
     3742            self._finishWithError()
     3743
     3744    def _finishWithError(self):
     3745        """Display an error dialog, and when it is accepted, cancel
     3746        SimBrief briefing and jump to the fuel page."""
     3747        dialog = Gtk.MessageDialog(parent = self._wizard.gui.mainWindow,
     3748                                   type = Gtk.MessageType.ERROR,
     3749                                   message_format =
     3750                                   xstr("simbrief_result_error_other") + "\n"+
     3751                                   xstr("simbrief_cancelled"))
     3752
     3753        dialog.add_button(xstr("button_ok"), Gtk.ResponseType.OK)
     3754        dialog.set_title(WINDOW_TITLE_BASE)
     3755        secondary = xstr("flightsel_save_failed_sec")
     3756        dialog.format_secondary_markup(secondary)
     3757        dialog.run()
     3758        dialog.hide()
     3759
     3760        self._wizard.usingSimBrief = False
     3761        self._wizard.jumpPage("fuel", fromPageShift = 1)
     3762
     3763
    35883764
    35893765#-----------------------------------------------------------------------------
    … …  
    36263802        self._button.set_use_stock(False)
    36273803
    3628     def activate(self):
    3629         """Activate the SimBrief flight plan page"""
     3804    def prepareShow(self):
     3805        """Prepare the page for showing (again)."""
    36303806        if self._browser is None:
    36313807            self._startBrowser()
    36323808        else:
    36333809            self._browser.Reload()
     3810
     3811    def prepareHide(self):
     3812        """Prepare the page for hiding."""
     3813        if os.name!="nt":
     3814            self._browser.CloseBrowser(False)
    36343815
    36353816    def grabDefault(self):
    … …  
    36613842            self._container = cef.getContainer()
    36623843            self._alignment.add(self._container)
     3844        else:
     3845            self._container.show()
    36633846
    36643847        url = "file://" + SimBriefSetupPage.getHTMLFilePath()
    … …  
    36703853    def _invalidateBrowser(self):
    36713854        """Invalidate the browser (and associated stuff)."""
    3672         self._alignment.remove(self._container)
    3673         self._container = None
     3855        self._container.hide()
    36743856        self._browser = None
    36753857
Note: See TracChangeset for help on using the changeset viewer.