Changeset 687:bb05f0618b5b


Ignore:
Timestamp:
10/18/15 14:53:02 (7 years ago)
Author:
István Váradi <ivaradi@…>
Branch:
cef
Phase:
public
Message:

SimBrief works basically (re #279)

Files:
4 edited

Legend:

Unmodified
Added
Removed
  • locale/en/mlx.po

    r684 r687  
    698698msgstr "The planned flight route in the standard format."
    699699
     700msgid "route_altn"
     701msgstr "_Alternate:"
     702
     703msgid "route_altn_tooltip"
     704msgstr "The ICAO code of the alternate airport."
     705
    700706msgid "route_down_notams"
    701707msgstr "Downloading NOTAMs..."
  • locale/hu/mlx.po

    r684 r687  
    697697msgstr "Az útvonal a szokásos formátumban."
    698698
     699msgid "route_altn"
     700msgstr "_Kitérő:"
     701
     702msgid "route_altn_tooltip"
     703msgstr "A kitérő repülőtér ICAO kódja."
     704
    699705msgid "route_down_notams"
    700706msgstr "NOTAM-ok letöltése..."
  • src/mlx/gui/flight.py

    r675 r687  
    11
    22from mlx.gui.common import *
     3import mlx.gui.cef as cef
    34
    45import mlx.const as const
     
    1718import time
    1819import os
     20import tempfile
    1921
    2022#-----------------------------------------------------------------------------
     
    14251427#-----------------------------------------------------------------------------
    14261428
     1429class RoutePage(Page):
     1430    """The page containing the route and the flight level."""
     1431    def __init__(self, wizard):
     1432        """Construct the page."""
     1433        super(RoutePage, self).__init__(wizard, xstr("route_title"),
     1434                                        xstr("route_help"),
     1435                                        completedHelp = xstr("route_chelp"))
     1436
     1437        alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
     1438                                  xscale = 0.0, yscale = 0.0)
     1439
     1440        mainBox = gtk.VBox()
     1441        alignment.add(mainBox)
     1442        self.setMainWidget(alignment)
     1443
     1444        levelBox = gtk.HBox()
     1445
     1446        label = gtk.Label(xstr("route_level"))
     1447        label.set_use_underline(True)
     1448        levelBox.pack_start(label, True, True, 0)
     1449
     1450        self._cruiseLevel = gtk.SpinButton()
     1451        self._cruiseLevel.set_increments(step = 10, page = 100)
     1452        self._cruiseLevel.set_range(min = 0, max = 500)
     1453        self._cruiseLevel.set_tooltip_text(xstr("route_level_tooltip"))
     1454        self._cruiseLevel.set_numeric(True)
     1455        self._cruiseLevel.connect("changed", self._cruiseLevelChanged)
     1456        self._cruiseLevel.connect("value-changed", self._cruiseLevelChanged)
     1457        label.set_mnemonic_widget(self._cruiseLevel)
     1458
     1459        levelBox.pack_start(self._cruiseLevel, False, False, 8)
     1460
     1461        alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
     1462                                  xscale = 0.0, yscale = 0.0)
     1463        alignment.add(levelBox)
     1464
     1465        mainBox.pack_start(alignment, False, False, 0)
     1466
     1467
     1468        routeBox = gtk.VBox()
     1469
     1470        alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
     1471                                  xscale = 0.0, yscale = 0.0)
     1472        label = gtk.Label(xstr("route_route"))
     1473        label.set_use_underline(True)
     1474        alignment.add(label)
     1475        routeBox.pack_start(alignment, True, True, 0)
     1476
     1477        routeWindow = gtk.ScrolledWindow()
     1478        routeWindow.set_size_request(400, 80)
     1479        routeWindow.set_shadow_type(gtk.ShadowType.IN if pygobject
     1480                                    else gtk.SHADOW_IN)
     1481        routeWindow.set_policy(gtk.PolicyType.AUTOMATIC if pygobject
     1482                               else gtk.POLICY_AUTOMATIC,
     1483                               gtk.PolicyType.AUTOMATIC if pygobject
     1484                               else gtk.POLICY_AUTOMATIC)
     1485
     1486        self._uppercasingRoute = False
     1487
     1488        self._route = gtk.TextView()
     1489        self._route.set_tooltip_text(xstr("route_route_tooltip"))
     1490        self._route.set_wrap_mode(WRAP_WORD)
     1491        self._route.get_buffer().connect("changed", self._routeChanged)
     1492        self._route.get_buffer().connect_after("insert-text", self._routeInserted)
     1493        routeWindow.add(self._route)
     1494
     1495        label.set_mnemonic_widget(self._route)
     1496        routeBox.pack_start(routeWindow, True, True, 0)
     1497
     1498        mainBox.pack_start(routeBox, True, True, 8)
     1499
     1500        alternateBox = gtk.HBox()
     1501
     1502        label = gtk.Label(xstr("route_altn"))
     1503        label.set_use_underline(True)
     1504        alternateBox.pack_start(label, True, True, 0)
     1505
     1506        self._alternate = gtk.Entry()
     1507        self._alternate.set_width_chars(6)
     1508        self._alternate.connect("changed", self._alternateChanged)
     1509        self._alternate.set_tooltip_text(xstr("route_altn_tooltip"))
     1510        label.set_mnemonic_widget(self._alternate)
     1511
     1512        alternateBox.pack_start(self._alternate, False, False, 8)
     1513
     1514        alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
     1515                                  xscale = 0.0, yscale = 0.0)
     1516        alignment.add(alternateBox)
     1517
     1518        mainBox.pack_start(alignment, False, False, 0)
     1519
     1520        self.addCancelFlightButton()
     1521
     1522        self._backButton = self.addPreviousButton(clicked = self._backClicked)
     1523        self._button = self.addNextButton(clicked = self._forwardClicked)
     1524
     1525    @property
     1526    def filedCruiseLevel(self):
     1527        """Get the filed cruise level."""
     1528        return self._cruiseLevel.get_value_as_int()
     1529
     1530    @property
     1531    def route(self):
     1532        """Get the route."""
     1533        return self._getRoute()
     1534
     1535    @property
     1536    def alternate(self):
     1537        """Get the ICAO code of the alternate airport."""
     1538        return self._alternate.get_text()
     1539
     1540    def activate(self):
     1541        """Setup the route from the booked flight."""
     1542        self._cruiseLevel.set_value(0)
     1543        self._cruiseLevel.set_text("")
     1544        self._route.get_buffer().set_text(self._wizard._bookedFlight.route)
     1545        self._updateForwardButton()
     1546
     1547    def _getRoute(self):
     1548        """Get the text of the route."""
     1549        buffer = self._route.get_buffer()
     1550        return buffer.get_text(buffer.get_start_iter(),
     1551                               buffer.get_end_iter(), True)
     1552
     1553    def _updateForwardButton(self):
     1554        """Update the sensitivity of the forward button."""
     1555        cruiseLevelText = self._cruiseLevel.get_text()
     1556        cruiseLevel = int(cruiseLevelText) if cruiseLevelText else 0
     1557        alternate = self._alternate.get_text()
     1558        self._button.set_sensitive(cruiseLevel>=50 and self._getRoute()!="" and
     1559                                   len(alternate)==4)
     1560
     1561    def _cruiseLevelChanged(self, *arg):
     1562        """Called when the cruise level has changed."""
     1563        self._updateForwardButton()
     1564
     1565    def _routeChanged(self, textBuffer):
     1566        """Called when the route has changed."""
     1567        if not self._uppercasingRoute:
     1568            self._updateForwardButton()
     1569
     1570    def _routeInserted(self, textBuffer, iter, text, length):
     1571        """Called when new characters are inserted into the route.
     1572
     1573        It uppercases all characters."""
     1574        if not self._uppercasingRoute:
     1575            self._uppercasingRoute = True
     1576
     1577            iter1 = iter.copy()
     1578            iter1.backward_chars(length)
     1579            textBuffer.delete(iter, iter1)
     1580
     1581            textBuffer.insert(iter, text.upper())
     1582
     1583            self._uppercasingRoute = False
     1584
     1585    def _alternateChanged(self, entry):
     1586        """Called when the alternate airport has changed."""
     1587        entry.set_text(entry.get_text().upper())
     1588        self._updateForwardButton()
     1589
     1590    def _backClicked(self, button):
     1591        """Called when the Back button is pressed."""
     1592        self.goBack()
     1593
     1594    def _forwardClicked(self, button):
     1595        """Called when the Forward button is clicked."""
     1596        if self._wizard.gui.config.useSimBrief:
     1597            self._wizard.nextPage()
     1598        else:
     1599            self._wizard.jumpPage(3)
     1600
     1601#-----------------------------------------------------------------------------
     1602
     1603class SimBriefSetupPage(Page):
     1604    """Page for setting up some parameters for SimBrief."""
     1605    monthNum2Name = [
     1606        "JAN",
     1607        "FEB",
     1608        "MAR",
     1609        "APR",
     1610        "MAY",
     1611        "JUN",
     1612        "JUL",
     1613        "AUG",
     1614        "SEP",
     1615        "OCT",
     1616        "NOV",
     1617        "DEC"
     1618        ]
     1619
     1620    @staticmethod
     1621    def getHTMLFilePath():
     1622        """Get the path of the HTML file to contain the generated flight
     1623        plan."""
     1624        if os.name=="nt":
     1625            return os.path.join(tempfile.gettempdir(),
     1626                                "mlx_simbrief" +
     1627                                (".secondary" if secondaryInstallation else "") +
     1628                                ".html")
     1629        else:
     1630            import pwd
     1631            return os.path.join(tempfile.gettempdir(),
     1632                                "mlx_simbrief." + pwd.getpwuid(os.getuid())[0] + "" +
     1633                                (".secondary" if secondaryInstallation else "") +
     1634                                ".html")
     1635
     1636    def __init__(self, wizard):
     1637        """Construct the setup page."""
     1638
     1639        super(SimBriefSetupPage, self).__init__(wizard,
     1640                                                "SimBrief setup",
     1641                                                "Complete the following data to "
     1642                                                "start generating your "
     1643                                                "SimBrief briefing.",
     1644                                                "Your SimBrief briefing was "
     1645                                                "generated with the following "
     1646                                                "data.")
     1647
     1648        alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
     1649                                  xscale = 0.0, yscale = 0.0)
     1650
     1651        table = gtk.Table(7, 3)
     1652        table.set_row_spacings(4)
     1653        table.set_col_spacings(16)
     1654        table.set_homogeneous(False)
     1655        alignment.add(table)
     1656        self.setMainWidget(alignment)
     1657
     1658        label = gtk.Label("_Username:")
     1659        label.set_use_underline(True)
     1660        label.set_alignment(0.0, 0.5)
     1661        table.attach(label, 0, 1, 0, 1)
     1662
     1663        self._userName = gtk.Entry()
     1664        self._userName.set_width_chars(16)
     1665        self._userName.connect("changed",
     1666                               lambda button: self._updateForwardButton())
     1667        self._userName.set_tooltip_text("Your SimBrief username")
     1668        table.attach(self._userName, 1, 2, 0, 1)
     1669        label.set_mnemonic_widget(self._userName)
     1670
     1671        label = gtk.Label("_Password:")
     1672        label.set_use_underline(True)
     1673        label.set_alignment(0.0, 0.5)
     1674        table.attach(label, 0, 1, 1, 2)
     1675
     1676        self._password = gtk.Entry()
     1677        self._password.set_visibility(False)
     1678        self._password.connect("changed",
     1679                               lambda button: self._updateForwardButton())
     1680        self._password.set_tooltip_text("Your SimBrief password")
     1681        table.attach(self._password, 1, 2, 1, 2)
     1682        label.set_mnemonic_widget(self._password)
     1683
     1684        self.addCancelFlightButton()
     1685
     1686        self._backButton = self.addPreviousButton(clicked = self._backClicked)
     1687        self._button = self.addNextButton(clicked = self._forwardClicked)
     1688
     1689    def activate(self):
     1690        """Activate the SimBrief setup page"""
     1691        self._updateForwardButton()
     1692
     1693    def _updateForwardButton(self):
     1694        """Update the sensitivity of the forward button."""
     1695        self._button.set_sensitive(len(self._userName.get_text())>0 and
     1696                                   len(self._password.get_text())>0)
     1697
     1698    def _backClicked(self, button):
     1699        """Called when the Back button is pressed."""
     1700        self.goBack()
     1701
     1702    def _forwardClicked(self, button):
     1703        if self._completed:
     1704            self._wizard.nextPage()
     1705        else:
     1706            plan = self._getPlan()
     1707            print "plan:", plan
     1708
     1709            userName = self._userName.get_text()
     1710            password = self._password.get_text()
     1711
     1712            self._wizard.gui.beginBusy("Calling SimBrief...")
     1713
     1714            cef.callSimBrief(plan,
     1715                             lambda count: (userName, password),
     1716                             self._simBriefProgressCallback,
     1717                             SimBriefSetupPage.getHTMLFilePath())
     1718
     1719            startSound(const.SOUND_NOTAM)
     1720
     1721    def _simBriefProgressCallback(self, message, done):
     1722        """Called by the SimBrief handling thread."""
     1723        gobject.idle_add(self._simBriefProgress, message, done)
     1724
     1725    def _simBriefProgress(self, message, done):
     1726        """The real SimBrief progress handler."""
     1727        if done:
     1728            self._wizard.gui.endBusy()
     1729            self._wizard.nextPage()
     1730        else:
     1731            self._wizard.gui.updateBusyState(message)
     1732
     1733    def _getPlan(self):
     1734        """Get the flight plan data for SimBrief."""
     1735        plan = {
     1736            "airline": "MAH",
     1737            "selcal": "XXXX",
     1738            "fuelfactor": "P000",
     1739            "contpct": "0.05",
     1740            "resvrule": "45",
     1741            "taxiout": "10",
     1742            "taxiin": "10",
     1743            "civalue": "AUTO"
     1744            }
     1745
     1746        wizard = self._wizard
     1747        gui = wizard.gui
     1748
     1749        loginResult = wizard.loginResult
     1750        plan["cpt"] = loginResult.pilotName
     1751        plan["pid"] = loginResult.pilotID
     1752
     1753        bookedFlight = wizard.bookedFlight
     1754        plan["fltnum"] = wizard.bookedFlight.callsign[2:]
     1755        plan["type"] = const.icaoCodes[bookedFlight.aircraftType]
     1756        plan["orig"] = bookedFlight.departureICAO
     1757        plan["dest"] = bookedFlight.arrivalICAO
     1758        plan["reg"] = bookedFlight.tailNumber
     1759        plan["fin"] = bookedFlight.tailNumber[3:]
     1760        plan["pax"] = str(bookedFlight.numPassengers)
     1761
     1762        departureTime = bookedFlight.departureTime
     1763        plan["date"] = "%d%s%d" % (departureTime.day,
     1764                                   SimBriefSetupPage.monthNum2Name[departureTime.month-1],
     1765                                   departureTime.year%100)
     1766        plan["deph"] = str(departureTime.hour)
     1767        plan["depm"] = str(departureTime.minute)
     1768
     1769        arrivalTime = bookedFlight.arrivalTime
     1770        plan["steh"] = str(arrivalTime.hour)
     1771        plan["stem"] = str(arrivalTime.minute)
     1772
     1773        plan["manualzfw"] = str(wizard.zfw)
     1774        plan["cargo"] = str(wizard.bagWeight + wizard.cargoWeight + wizard.mailWeight)
     1775
     1776        plan["route"] = wizard.route
     1777        plan["fl"] = str(wizard.filedCruiseAltitude)
     1778        plan["altn"] = wizard.alternate
     1779
     1780        plan["addedfuel"] = "2.5" # FIXME: query
     1781        plan["origrwy"] = "" # FIXME: query
     1782        plan["destrwy"] = "" # FIXME: query
     1783        plan["climb"] = "250/300/78" # FIXME: query
     1784        plan["descent"] = "80/280/250" # FIXME: query
     1785        plan["cruise"] = "LRC" # FIXME: query
     1786
     1787        return plan
     1788
     1789#-----------------------------------------------------------------------------
     1790
     1791class SimBriefingPage(Page):
     1792    """Page to display the SimBrief HTML briefing."""
     1793    def __init__(self, wizard):
     1794        """Construct the setup page."""
     1795
     1796        super(SimBriefingPage, self).__init__(wizard,
     1797                                              "SimBrief flight plan", "")
     1798
     1799        self._alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
     1800                                       xscale = 1.0, yscale = 1.0)
     1801
     1802        self.setMainWidget(self._alignment)
     1803
     1804        self.addCancelFlightButton()
     1805
     1806        self.addPreviousButton(clicked = self._backClicked)
     1807
     1808        self._button = self.addNextButton(clicked = self._forwardClicked)
     1809        self._button.set_label(xstr("briefing_button"))
     1810        self._button.set_has_tooltip(False)
     1811        self._button.set_use_stock(False)
     1812
     1813    def activate(self):
     1814        """Activate the SimBrief flight plan page"""
     1815        container = cef.getContainer()
     1816        self._alignment.add(container)
     1817
     1818        self._browser = \
     1819          cef.startInContainer(container,
     1820                               "file://" + SimBriefSetupPage.getHTMLFilePath())
     1821
     1822    def _backClicked(self, button):
     1823        """Called when the Back button has been pressed."""
     1824        self.goBack()
     1825
     1826    def _forwardClicked(self, button):
     1827        """Called when the Forward button has been pressed."""
     1828        if not self._completed:
     1829            self._button.set_label(xstr("button_next"))
     1830            self._button.set_tooltip_text(xstr("button_next_tooltip"))
     1831            self._wizard.usingSimBrief = True
     1832            self.complete()
     1833
     1834        self._wizard.nextPage()
     1835
     1836#-----------------------------------------------------------------------------
     1837
    14271838class FuelTank(gtk.VBox):
    14281839    """Widget for the fuel tank."""
     
    16602071            self._wizard.gui.beginBusy(xstr("fuel_pump_busy"))
    16612072            self._pump()
     2073        elif self._wizard.usingSimBrief:
     2074            self._wizard.jumpPage(3)
    16622075        else:
    16632076            self._wizard.nextPage()
     
    17052118        if fuelTank is None:
    17062119            self._wizard.gui.endBusy()
    1707             self._wizard.nextPage()
     2120            if self._wizard.usingSimBrief:
     2121                self._wizard.gui.startMonitoring()
     2122                self._wizard.jumpPage(3)
     2123            else:
     2124                bookedFlight = self._wizard._bookedFlight
     2125                self._wizard.gui.beginBusy(xstr("route_down_notams"))
     2126                self._wizard.gui.webHandler.getNOTAMs(self._notamsCallback,
     2127                                                      bookedFlight.departureICAO,
     2128                                                      bookedFlight.arrivalICAO)
     2129                startSound(const.SOUND_NOTAM)
    17082130        else:
    17092131            currentLevel = fuelTank.currentWeight / fuelTank.capacity
     
    17192141                                                      currentLevel)])
    17202142            gobject.timeout_add(50, self._pump)
    1721 
    1722 #-----------------------------------------------------------------------------
    1723 
    1724 class RoutePage(Page):
    1725     """The page containing the route and the flight level."""
    1726     def __init__(self, wizard):
    1727         """Construct the page."""
    1728         super(RoutePage, self).__init__(wizard, xstr("route_title"),
    1729                                         xstr("route_help"),
    1730                                         completedHelp = xstr("route_chelp"))
    1731 
    1732         alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
    1733                                   xscale = 0.0, yscale = 0.0)
    1734 
    1735         mainBox = gtk.VBox()
    1736         alignment.add(mainBox)
    1737         self.setMainWidget(alignment)
    1738 
    1739         levelBox = gtk.HBox()
    1740 
    1741         label = gtk.Label(xstr("route_level"))
    1742         label.set_use_underline(True)
    1743         levelBox.pack_start(label, True, True, 0)
    1744 
    1745         self._cruiseLevel = gtk.SpinButton()
    1746         self._cruiseLevel.set_increments(step = 10, page = 100)
    1747         self._cruiseLevel.set_range(min = 0, max = 500)
    1748         self._cruiseLevel.set_tooltip_text(xstr("route_level_tooltip"))
    1749         self._cruiseLevel.set_numeric(True)
    1750         self._cruiseLevel.connect("changed", self._cruiseLevelChanged)
    1751         self._cruiseLevel.connect("value-changed", self._cruiseLevelChanged)
    1752         label.set_mnemonic_widget(self._cruiseLevel)
    1753 
    1754         levelBox.pack_start(self._cruiseLevel, False, False, 8)
    1755 
    1756         alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
    1757                                   xscale = 0.0, yscale = 0.0)
    1758         alignment.add(levelBox)
    1759 
    1760         mainBox.pack_start(alignment, False, False, 0)
    1761 
    1762 
    1763         routeBox = gtk.VBox()
    1764 
    1765         alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
    1766                                   xscale = 0.0, yscale = 0.0)
    1767         label = gtk.Label(xstr("route_route"))
    1768         label.set_use_underline(True)
    1769         alignment.add(label)
    1770         routeBox.pack_start(alignment, True, True, 0)
    1771 
    1772         routeWindow = gtk.ScrolledWindow()
    1773         routeWindow.set_size_request(400, 80)
    1774         routeWindow.set_shadow_type(gtk.ShadowType.IN if pygobject
    1775                                     else gtk.SHADOW_IN)
    1776         routeWindow.set_policy(gtk.PolicyType.AUTOMATIC if pygobject
    1777                                else gtk.POLICY_AUTOMATIC,
    1778                                gtk.PolicyType.AUTOMATIC if pygobject
    1779                                else gtk.POLICY_AUTOMATIC)
    1780 
    1781         self._uppercasingRoute = False
    1782 
    1783         self._route = gtk.TextView()
    1784         self._route.set_tooltip_text(xstr("route_route_tooltip"))
    1785         self._route.set_wrap_mode(WRAP_WORD)
    1786         self._route.get_buffer().connect("changed", self._routeChanged)
    1787         self._route.get_buffer().connect_after("insert-text", self._routeInserted)
    1788         routeWindow.add(self._route)
    1789 
    1790         label.set_mnemonic_widget(self._route)
    1791         routeBox.pack_start(routeWindow, True, True, 0)
    1792 
    1793         mainBox.pack_start(routeBox, True, True, 8)
    1794 
    1795         self.addCancelFlightButton()
    1796 
    1797         self._backButton = self.addPreviousButton(clicked = self._backClicked)
    1798         self._button = self.addNextButton(clicked = self._forwardClicked)
    1799 
    1800     @property
    1801     def filedCruiseLevel(self):
    1802         """Get the filed cruise level."""
    1803         return self._cruiseLevel.get_value_as_int()
    1804 
    1805     @property
    1806     def route(self):
    1807         """Get the route."""
    1808         return self._getRoute()
    1809 
    1810     def activate(self):
    1811         """Setup the route from the booked flight."""
    1812         self._cruiseLevel.set_value(0)
    1813         self._cruiseLevel.set_text("")
    1814         self._route.get_buffer().set_text(self._wizard._bookedFlight.route)
    1815         self._updateForwardButton()
    1816 
    1817     def _getRoute(self):
    1818         """Get the text of the route."""
    1819         buffer = self._route.get_buffer()
    1820         return buffer.get_text(buffer.get_start_iter(),
    1821                                buffer.get_end_iter(), True)
    1822 
    1823     def _updateForwardButton(self):
    1824         """Update the sensitivity of the forward button."""
    1825         cruiseLevelText = self._cruiseLevel.get_text()
    1826         cruiseLevel = int(cruiseLevelText) if cruiseLevelText else 0
    1827         self._button.set_sensitive(cruiseLevel>=50 and self._getRoute()!="")
    1828 
    1829     def _cruiseLevelChanged(self, *arg):
    1830         """Called when the cruise level has changed."""
    1831         self._updateForwardButton()
    1832 
    1833     def _routeChanged(self, textBuffer):
    1834         """Called when the route has changed."""
    1835         if not self._uppercasingRoute:
    1836             self._updateForwardButton()
    1837 
    1838     def _routeInserted(self, textBuffer, iter, text, length):
    1839         """Called when new characters are inserted into the route.
    1840 
    1841         It uppercases all characters."""
    1842         if not self._uppercasingRoute:
    1843             self._uppercasingRoute = True
    1844 
    1845             iter1 = iter.copy()
    1846             iter1.backward_chars(length)
    1847             textBuffer.delete(iter, iter1)
    1848 
    1849             textBuffer.insert(iter, text.upper())
    1850 
    1851             self._uppercasingRoute = False
    1852 
    1853     def _backClicked(self, button):
    1854         """Called when the Back button is pressed."""
    1855         self.goBack()
    1856 
    1857     def _forwardClicked(self, button):
    1858         """Called when the Forward button is clicked."""
    1859         if self._completed:
    1860             self._wizard.nextPage()
    1861         else:
    1862             bookedFlight = self._wizard._bookedFlight
    1863             self._wizard.gui.beginBusy(xstr("route_down_notams"))
    1864             self._wizard.gui.webHandler.getNOTAMs(self._notamsCallback,
    1865                                                   bookedFlight.departureICAO,
    1866                                                   bookedFlight.arrivalICAO)
    1867             startSound(const.SOUND_NOTAM)
    18682143
    18692144    def _notamsCallback(self, returned, result):
     
    35783853        self._payloadIndex = len(self._pages)
    35793854        self._pages.append(TimePage(self))
    3580         self._pages.append(FuelPage(self))
    35813855        self._routePage = RoutePage(self)
    35823856        self._pages.append(self._routePage)
     3857        self._simBriefSetupPage = SimBriefSetupPage(self)
     3858        self._pages.append(self._simBriefSetupPage)
     3859        self._simBriefingPage = SimBriefingPage(self)
     3860        self._pages.append(self._simBriefingPage)
     3861        self._pages.append(FuelPage(self))
    35833862        self._departureBriefingPage = BriefingPage(self, True)
    35843863        self._pages.append(self._departureBriefingPage)
     
    37414020
    37424021    @property
     4022    def alternate(self):
     4023        """Get the ICAO code of the alternate airport."""
     4024        return self._routePage.alternate
     4025
     4026    @property
    37434027    def departureMETAR(self):
    37444028        """Get the METAR of the departure airport."""
     
    38394123        """Get whether the flight was online or not."""
    38404124        return self._finishPage.online
     4125
     4126    @property
     4127    def usingSimBrief(self):
     4128        """Indicate if we are using a SimBrief briefing or not."""
     4129        return self._usingSimBrief
     4130
     4131    @usingSimBrief.setter
     4132    def usingSimBrief(self, x):
     4133        """Set whether we are using a SimBrief briefing or not."""
     4134        self._usingSimBrief = x
    38414135
    38424136    def nextPage(self, finalize = True):
     
    38954189        self._arrivalNOTAMs = None
    38964190        self._arrivalMETAR = None
     4191        self._usingSimBrief = False
    38974192
    38984193        firstPage = 0 if self._loginResult is None else 1
  • src/mlx/gui/gui.py

    r686 r687  
    14941494        """Called when CEF has been initialized."""
    14951495        self._acars.start()
     1496        cef.initializeSimBrief()
    14961497
    14971498    def _bugReportSentCallback(self, returned, result):
Note: See TracChangeset for help on using the changeset viewer.