Ignore:
Files:
2 added
18 edited

Legend:

Unmodified
Added
Removed

  • .hgignore

    r276 r442  
    66mlx-common.nsh
    77locale/.+/LC_MESSAGES
     8locale/.+/mlx_delay.po
     9src/mlx/gui/dcdata.py
     10xplra.py

  • .hgtags

    r419 r449  
    88cc775599652d39ab574dac90fe8730ef52842744 version_0.14
    99e11be493e87d09619387e352c389208cca54097d version_0.15
     1089c9d5d516eb0da04f2cd10db58332f054249bb1 version_0.16

  • Makefile

    r276 r439  
    33all: $(foreach lang,$(LANGUAGES),locale/$(lang)/LC_MESSAGES/mlx.mo)
    44
    5 locale/%/LC_MESSAGES/mlx.mo: locale/%/mlx.po
     5locale/%/LC_MESSAGES/mlx.mo: locale/%/mlx.po locale/%/mlx_delay.po
    66        mkdir -p `dirname $@`
    7         msgfmt -o $@ $^
     7        msgcat $^ | msgfmt -o $@ -
     8
     9locale/hu/mlx_delay.po locale/en/mlx_delay.po: dcdatagen.py
     10        ./dcdatagen.py

  • doc/overview.dox

    r302 r444  
    1111 * Note, that to be able to understand the code most effectively, it
    1212 * is important to either use the application actively, or to read its
    13  * user documentation carefully. 
     13 * user documentation carefully.
    1414 *
    1515 * \section overview Overview
    1616 *
    17  * The application was written in 
     17 * The application was written in
    1818 * <a href="http://python.org">Python 2</a>. The Python wrapper
    1919 * <a href="http://gtk.org">Gtk+</a> toolkit was used for the graphical
    … …  
    2323 * as the primary toolkit, while it has no reliable port for Windows
    2424 * yet. Therefore it was decided to support both Gtk+ 2 and 3
    25  * depending on the platform. For Gtk+ 2 the 
     25 * depending on the platform. For Gtk+ 2 the
    2626 * <a href="http://pygtk.org">PyGTK</a> wrapper is used, while for Gtk+
    2727 * 3 the <a href="https://live.gnome.org/PyGObject">PyGObject</a>
    … …  
    3333 * <a href="http://www.schiratti.com/dowson.html">FSUIPC</a>
    3434 * interface. The author has created a Python mapping for it, which
    35  * has been submitted for inclusion into the SDK, so it will hopefully 
     35 * has been submitted for inclusion into the SDK, so it will hopefully
    3636 * appear in its next version. It is planned to support X-Plane in the
    3737 * near future (hopefully by the end of 2012) on both Linux and
    … …  
    4545 * Gtk+ and Gtk+ itself. Since Python is an interpreted language,
    4646 * there is no need for any special build system.
    47  * 
     47 *
    4848 * Python and Gtk+ are readily available on most Linux distributions,
    4949 * but some links are probably useful for Windows users:
    … …  
    5454 * \li To create install packages, you also need py2exe: <a href="http://www.py2exe.org/">http://www.py2exe.org</a>,
    5555 * \li as well as the Nullsoft Install System: http://nsis.sourceforge.net/Main_Page
    56  * 
     56 *
    5757 * The install package can be created by running the \c makeinst.bat
    5858 * file. It contains some absolute paths, so check those befure
    … …  
    8181 *    thread. Instead, use \c gobject.idle_add to "inject" the
    8282 *    operation into the main thread.
    83  * -# To ensure the responsiveness of the GUI, only operations 
     83 * -# To ensure the responsiveness of the GUI, only operations
    8484 *    that take a short time should be executed in the GUI thread.
    8585 *
    … …  
    9898 * simulator is to be supported, a class with the same (or at least
    9999 * sufficiently similar) public interface should be implemented.
    100  *             
     100 *
    101101 * The most important function of the program is the
    102102 * continuous monitoring of the aircraft's parameters and some other
    103103 * data. The monitoring is started using the \ref
    104104 * mlx.fsuipc.Simulator.startMonitoring "startMonitoring" function of
    105  * the simulator object. If started, it calls the \ref 
     105 * the simulator object. If started, it calls the \ref
    106106 * mlx.acft.Aircraft.handleState "handleState" function of the
    107107 * mlx.acft.Aircraft instance used. The mlx.acft module contains one
    … …  
    114114 * smoothed values of IAS and VS, and then calls each "checker". A
    115115 * checker is an instance of a subclass of mlx.checks.StateChecker,
    116  * which checks a one or a few parameters that are important from some 
     116 * which checks a one or a few parameters that are important from some
    117117 * aspect of the correct execution of a flight. For example, a checker
    118  * may check if the \ref mlx.checks.StrobeLightsChecker 
     118 * may check if the \ref mlx.checks.StrobeLightsChecker
    119119 * "strobe lights" are switched on and off at the right stages of the
    120120 * flight. But some checkers simply log some \ref
    121121 * mlx.checks.AltimeterLogger "value" whenever it changes
    122122 * in an "interesting" way, or \ref mlx.checks.ACARSSender "send the
    123  * ACARS" periodically. 
     123 * ACARS" periodically.
    124124 *
    125125 * There is also a \ref mlx.checks.StageCheker "checker" which
    126126 * detects the changes in the stage of the flight, and calls the
    127127 * \ref mlx.acft.Aircraft.setStage "setStage" function of the
    128  * aircraft, if there is a change. It first calls the 
     128 * aircraft, if there is a change. It first calls the
    129129 * \ref mlx.flight.Flight "flight"'s \ref mlx.flight.Flight.setStage
    130130 * "setStage" function, which notifies the GUI and the \ref
    … …  
    139139 * mlx.soundsched.SoundScheduler "sound scheduler" to check if some
    140140 * backround sound should be played. If the check list hotkey is
    141  * pressed, the \ref mlx.soundsched.ChecklistScheduler 
     141 * pressed, the \ref mlx.soundsched.ChecklistScheduler
    142142 * "checklist scheduler" is notified too.
    143143 *
    144144 * As mentioned, there is a \ref mlx.logger.Logger "logger" in the
    145145 * application, which contains the textual log lines as well as the
    146  * faults and their scores. 
     146 * faults and their scores.
    147147 *
    148148 * The business logic part contains many other components, but they
    … …  
    151151 * modules for more information.
    152152 *
    153  * \subsection arch_gui GUI     
     153 * \subsection arch_gui GUI
    154154 *
    155155 * As mentioned, the GUI is implemented using Gtk+. This toolkit
    … …  
    158158 * experience with Glade in an earlier project, it was decided to not
    159159 * use it. Instead, the GUI elements are created and handled by
    160  * hand-written code. 
     160 * hand-written code.
    161161 *
    162162 * The central class of the graphical user interface is
    … …  
    165165 * connection to the simulator and creates the \ref mlx.flight.Flight
    166166 * "flight" and \ref mlx.flight.Aircraft "aircraft" objects as
    167  * needed. 
     167 * needed.
    168168 *
    169169 * To understand the operation of the GUI, one should be familiar with
    170170 * Gtk+, but otherwise it is pretty straighforward. See the
    171  * documentation of the relevant modules for more information.
     171 * documentation of the relevant modules for more information.
     172 *
     173 * \section newtype Adding a new aircraft type
     174 *
     175 * While new aircraft types will probably not be added too often, here
     176 * is a checklist about what should be modified when such a
     177 * requirement arises.
     178 *
     179 * First, it is worth to know what data you need to add the new type:
     180 *
     181 * \li the aircraft's type name and its ICAO code
     182 * \li the following weights: DOW, MZFW, MTOW, MLW
     183 * \li the flap settings and their speed limits
     184 * \li the speed limit for extending/retracting the gear (VLE)
     185 * \li the number and types of the fuel tanks
     186 * \li the type code the MAVA website uses to identify the type
     187 * \li if the plane has reversers, what is the operating limit speed,
     188 *     if any
     189 * \li does the plane support the notion of a takeoff derate, and if
     190 *     so, what data should be given
     191 * \li what lights does the plane have
     192 *
     193 * If you have the data, you can add the type by modifying the source
     194 * files as per the checklist below:
     195 *
     196 * -# \c src/mlx/const.py: look for the constants named AIRCRAFT_xxx.
     197 *    Add the new type at the end of the list of those constants, with
     198 *    a number 1 greater than the number of the last existing
     199 *    type. The part of the constant's name after the underscore (xxx
     200 *    above) should be the ICAO code of the aircraft type.
     201 * -# \c src/mlx/const.py: below this list of constants, you can find
     202 *    an array named \c aircraftTypes. Add the type constant to it.
     203 * -# \c src/mlx/const.py: further below you can find a dictionary
     204 *    mapping te aircraft type to the corresponding ICAO codes. Add
     205 *    the new type to it.
     206 * -# \c src/mlx/acft.py: add a new subclass of \ref
     207 *    mlx.acft.Aircraft. Its name should be the ICAO code. Check an
     208 *    existing aircraft and add the same variables containing the
     209 *    weights, the flap speed limits and the gear speed limit. There
     210 *    may be some other member variables or functions that should be
     211 * -# \c src/mlx/acft.py: there is a dictionary named \c _classes
     212 *    towards the end of the file. Add the type to it.
     213 * -# \c src/mlx/web.py: the \ref mlx.web.BookedFlight class contains
     214 *    two dictionaries, the mapping between the types and the values the MAVA
     215 *    website uses to identify the type. Add the appropriate values
     216 *    here.
     217 * -# \c src/mlx/fsuipc.py: add a subclass of \ref
     218 *    mlx.fsuipc.GenericAircraftModel for the new type named the ICAO
     219 *    code of the type followed by the word \c Model. Implement its
     220 *    constructor to supply the base class with the flaps notches
     221 *    (starting with 0), the array of constants describing the fuel
     222 *    tanks the model has, and the number of engines. Also implement
     223 *    the name of the model, which should be something like
     224 *    "FSUIPC/Generic ...". If necessary implement other functions or
     225 *    set other members.
     226 * -# \c src/mlx/fsuipc.py: add the new type and model class to the
     227 *    dictionary named \c _genericModels towards the end of the file.
     228 * -# \c src/mlx/fsuipc.py: if you have a model that has some
     229 *    non-generic characteristics, create a specific class for
     230 *    it. This class should be a subclass of the generic class
     231 *    created, and it should be registered at the bottom of the file,
     232 *    as the other models are.
     233 * -# \c src/mlx/gui/common.py: this file contains a dictionary called
     234 *    \c mlx.gui.common.aircraftNames. Add the new type it it. It
     235 *    contains the mapping from the type constants to their
     236 *    language-specific names. The string ID is "aircraft_" followed by
     237 *    the lower-cased ICAO code.
     238 * -# \c locale/hu/mlx.po, locale/en/mlx.po: the beginning of this
     239 *    file contains mapping from the string ID previously used to the
     240 *    actual name of the aircraft. Add the new type as appropriate.
     241 * -# \c dcdatagen.py: this program generates some source and message
     242 *    files related to the delay codes. Currently there are two
     243 *    tables, one for old-timer types and the other for the "modern" types.
     244 *    The file contains a list of lists called \c typeGroups. Add the
     245 *    type's ICAO code the appropriate list.
     246 *
     247 * When all the changes have been made, run \c make in the root
     248 * directory to update some source files.
    172249 */
    173  

  • locale/en/mlx.po

    r393 r445  
    6363msgid "aircraft_yk40"
    6464msgstr "Yakovlev Yak-40"
     65
     66msgid "aircraft_b462"
     67msgstr "British Aerospace 146-200"
    6568
    6669msgid "file_filter_all"
    … …  
    777780msgstr "N_ominal/takeoff:"
    778781
     782msgid "takeoff_derate_b462"
     783msgstr "Der_ate (yes/no):"
     784
    779785msgid "takeoff_derate_tooltip"
    780786msgstr "Enter the takeoff derate parameter."
    … …  
    971977msgid "info_delay"
    972978msgstr "Delay codes"
    973 
    974 msgid "info_delay_loading"
    975 msgstr "L_oading problems"
    976 
    977 msgid "info_delay_vatsim"
    978 msgstr "_VATSIM problem"
    979 
    980 msgid "info_delay_net"
    981 msgstr "_Net problems"
    982 
    983 msgid "info_delay_atc"
    984 msgstr "Controll_er's fault"
    985 
    986 msgid "info_delay_system"
    987 msgstr "S_ystem crash/freeze"
    988 
    989 msgid "info_delay_nav"
    990 msgstr "Naviga_tion problem"
    991 
    992 msgid "info_delay_traffic"
    993 msgstr "T_raffic problems"
    994 
    995 msgid "info_delay_apron"
    996 msgstr "_Apron navigation problem"
    997 
    998 msgid "info_delay_weather"
    999 msgstr "_Weather problems"
    1000 
    1001 msgid "info_delay_personal"
    1002 msgstr "_Personal reasons"
    1003979
    1004980msgid "statusbar_conn_tooltip"

  • locale/hu/mlx.po

    r393 r445  
    6464msgstr "Jakovlev Jak-40"
    6565
     66msgid "aircraft_b462"
     67msgstr "British Aerospace 146-200"
     68
    6669msgid "file_filter_all"
    6770msgstr "Összes fájl"
    … …  
    778781msgstr "Névleges/felszállási:"
    779782
     783msgid "takeoff_derate_b462"
     784msgstr "Teljesítménycsökkentés (yes/no):"
     785
    780786msgid "takeoff_derate_tooltip"
    781787msgstr "Írd be a felszállási teljesítménycsökkentés értékét."
    … …  
    974980msgid "info_delay"
    975981msgstr "Késés kódok"
    976 
    977 msgid "info_delay_loading"
    978 msgstr "_Betöltési problémák"
    979 
    980 msgid "info_delay_vatsim"
    981 msgstr "_VATSIM probléma"
    982 
    983 msgid "info_delay_net"
    984 msgstr "_Hálózati problémák"
    985 
    986 msgid "info_delay_atc"
    987 msgstr "Irán_yító hibája"
    988 
    989 msgid "info_delay_system"
    990 msgstr "_Rendszer elszállás/fagyás"
    991 
    992 msgid "info_delay_nav"
    993 msgstr "Navi_gációs probléma"
    994 
    995 msgid "info_delay_traffic"
    996 msgstr "_Forgalmi problémák"
    997 
    998 msgid "info_delay_apron"
    999 msgstr "_Előtér navigációs probléma"
    1000 
    1001 msgid "info_delay_weather"
    1002 msgstr "Időjárási _problémák"
    1003 
    1004 msgid "info_delay_personal"
    1005 msgstr "S_zemélyes okok"
    1006982
    1007983msgid "statusbar_conn_tooltip"

  • src/mlx/acft.py

    r409 r447  
    152152        self._checkers.append(checks.VSChecker())
    153153
    154         timeout = 5.0 + config.realIASSmoothingLength - 1
     154        timeout = 30.0 + config.realIASSmoothingLength - 1
    155155        self._checkers.append(checks.OverspeedChecker(timeout = timeout))
    156156
    … …  
    10171017#---------------------------------------------------------------------------------------
    10181018
     1019class B462(Aircraft):
     1020    """British Aerospace BAe-146 aircraft.
     1021
     1022    The aircraft type-specific values in the aircraft state have the following
     1023    structure:
     1024    - fuel: left, centre, right
     1025    - n1: left outer, left inner, right inner, right outer
     1026    - reverser: empty (the plane has no reversers)"""
     1027    def __init__(self, flight):
     1028        super(B462, self).__init__(flight)
     1029        self.dow = 25706
     1030        self.mtow = 43998
     1031        self.mlw = 38599
     1032        self.mzfw = 33792
     1033        self.gearSpeedLimit = 210
     1034        self.flapSpeedLimits = { 18 : 217,
     1035                                 24 : 180,
     1036                                 30 : 170,
     1037                                 33 : 150 }
     1038
     1039    @property
     1040    def derateLabels(self):
     1041        """Get the derate strings for this type."""
     1042        return (xstr("takeoff_derate_b462"), None)
     1043
     1044    @property
     1045    def derateTemplate(self):
     1046        """Get the derate template for this aicraft type."""
     1047        return "Derate enabled: %s"
     1048
     1049#---------------------------------------------------------------------------------------
     1050
    10191051mostFuelTanks = [const.FUELTANK_LEFT_TIP, const.FUELTANK_EXTERNAL1,
    10201052                 const.FUELTANK_LEFT_AUX,
    … …  
    10401072             const.AIRCRAFT_T134  : T134,
    10411073             const.AIRCRAFT_T154  : T154,
    1042              const.AIRCRAFT_YK40  : YK40 }
     1074             const.AIRCRAFT_YK40  : YK40,
     1075             const.AIRCRAFT_B462  : B462 }
    10431076
    10441077#---------------------------------------------------------------------------------------

  • src/mlx/checks.py

    r430 r450  
    10541054    def isCondition(self, flight, aircraft, oldState, state):
    10551055        """Check if the fault condition holds."""
    1056         return state.gLoad>2.0 and (flight.stage!=const.STAGE_LANDING or \
    1057                                     state.radioAltitude>=50)
     1056        return state.gLoad>2.0 and not state.onTheGround and \
     1057          (flight.stage!=const.STAGE_LANDING or state.radioAltitude>=50)
    10581058
    10591059    def logFault(self, flight, aircraft, logger, oldState, state):
    … …  
    11221122                 (flight.stage in
    11231123                  [const.STAGE_CRUISE, const.STAGE_DESCENT,
    1124                    const.STAGE_LANDING, const.STAGE_GOAROUND] or \
     1124                   const.STAGE_GOAROUND] or \
     1125                  (flight.stage==const.STAGE_LANDING  and
     1126                   state.groundSpeed>50.0) or \
    11251127                  ((not state.autoXPDR or \
    11261128                    (self._liftOffTime is not None and
    … …  
    12391241class OverspeedChecker(PatientFaultChecker):
    12401242    """Check if Vne has been exceeded."""
    1241     def __init__(self, timeout = 5.0):
     1243    def __init__(self, timeout = 30.0):
    12421244        """Construct the checker."""
    12431245        super(OverspeedChecker, self).__init__(timeout = timeout)
    … …  
    13081310        return flight.stage in [const.STAGE_DESCENT, const.STAGE_LANDING,
    13091311                                const.STAGE_TAXIAFTERLAND] and \
     1312            state.reverser and \
    13101313            state.groundSpeed<aircraft.reverseMinSpeed and max(state.reverser)
    13111314

  • src/mlx/const.py

    r417 r443  
    1111
    1212## The version of the program
    13 VERSION="0.15"
     13VERSION="0.16"
    1414
    1515#-------------------------------------------------------------------------------
    … …  
    9595## Aircraft type: Yakovlev Yak-40
    9696AIRCRAFT_YK40 = 15
     97
     98## Aircraft type: British Aerospace BAe-146
     99AIRCRAFT_B462 = 16
    97100
    98101#-------------------------------------------------------------------------------
    … …  
    108111                 AIRCRAFT_B733, AIRCRAFT_B734, AIRCRAFT_B735,
    109112                 AIRCRAFT_T154, AIRCRAFT_T134,
    110                  AIRCRAFT_YK40, AIRCRAFT_DC3]
     113                 AIRCRAFT_YK40, AIRCRAFT_DC3,
     114                 AIRCRAFT_B462]
    111115
    112116#-------------------------------------------------------------------------------
    … …  
    129133              AIRCRAFT_T134  : "T134",
    130134              AIRCRAFT_T154  : "T154",
    131               AIRCRAFT_YK40  : "YK40" }
     135              AIRCRAFT_YK40  : "YK40",
     136              AIRCRAFT_B462  : "B462" }
    132137
    133138#-------------------------------------------------------------------------------
    … …  
    237242#-------------------------------------------------------------------------------
    238243
    239 ## Delay code: loading problems
    240 DELAYCODE_LOADING = 0
    241 
    242 ## Delay code: VATSIM problem
    243 DELAYCODE_VATSIM = 1
    244 
    245 ## Delay code: network problems
    246 DELAYCODE_NETWORK = 2
    247 
    248 ## Delay code: controller's fault
    249 DELAYCODE_CONTROLLER = 3
    250 
    251 ## Delay code: system crash or freeze
    252 DELAYCODE_SYSTEM = 4
    253 
    254 ## Delay code: navigation problem
    255 DELAYCODE_NAVIGATION = 5
    256 
    257 ## Delay code: traffic problems
    258 DELAYCODE_TRAFFIC = 6
    259 
    260 ## Delay code: apron navigation
    261 DELAYCODE_APRON = 7
    262 
    263 ## Delay code: weather problems
    264 DELAYCODE_WEATHER = 8
    265 
    266 ## Delay code: personal reasons
    267 DELAYCODE_PERSONAL = 9
    268 
    269 #-------------------------------------------------------------------------------
    270 
    271244## Message type: logger error
    272245# FIXME: cannot set the hotkey

  • src/mlx/fsuipc.py

    r412 r443  
    20432043#------------------------------------------------------------------------------
    20442044
     2045class B462Model(GenericAircraftModel):
     2046    """Generic model for the British Aerospace BAe 146-200 aircraft."""
     2047    fuelTanks = [const.FUELTANK_LEFT, const.FUELTANK_CENTRE,
     2048                 const.FUELTANK_RIGHT]
     2049
     2050    def __init__(self):
     2051        """Construct the model."""
     2052        super(B462Model, self). \
     2053            __init__(flapsNotches = [0, 18, 24, 30, 33],
     2054                     fuelTanks = B462Model.fuelTanks,
     2055                     numEngines = 4)
     2056
     2057    @property
     2058    def name(self):
     2059        """Get the name for this aircraft model."""
     2060        return "FSUIPC/Generic British Aerospace 146"
     2061
     2062    def getAircraftState(self, aircraft, timestamp, data):
     2063        """Get an aircraft state object for the given monitoring data.
     2064
     2065        This removes the reverser value for the middle engine."""
     2066        state = super(B462Model, self).getAircraftState(aircraft, timestamp, data)
     2067        state.reverser = []
     2068        return state
     2069
     2070#------------------------------------------------------------------------------
     2071
    20452072_genericModels = { const.AIRCRAFT_B736  : B737Model,
    20462073                   const.AIRCRAFT_B737  : B737Model,
    … …  
    20582085                   const.AIRCRAFT_T134  : T134Model,
    20592086                   const.AIRCRAFT_T154  : T154Model,
    2060                    const.AIRCRAFT_YK40  : YK40Model }
     2087                   const.AIRCRAFT_YK40  : YK40Model,
     2088                   const.AIRCRAFT_B462  : B462Model }
    20612089
    20622090#------------------------------------------------------------------------------

  • src/mlx/gui/common.py

    r401 r443  
    7373
    7474    SHADOW_IN = gtk.SHADOW_IN
     75    SHADOW_NONE = gtk.SHADOW_NONE
    7576
    7677    POLICY_AUTOMATIC = gtk.POLICY_AUTOMATIC
    … …  
    8687
    8788    EVENT_BUTTON_PRESS = gdk.BUTTON_PRESS
     89
     90    TREE_VIEW_COLUMN_FIXED = gtk.TREE_VIEW_COLUMN_FIXED
     91
     92    FILL = gtk.FILL
     93    EXPAND = gtk.EXPAND
    8894
    8995    pixbuf_new_from_file = gdk.pixbuf_new_from_file
    … …  
    139145
    140146    SHADOW_IN = gtk.ShadowType.IN
     147    SHADOW_NONE = gtk.ShadowType.NONE
    141148
    142149    POLICY_AUTOMATIC = gtk.PolicyType.AUTOMATIC
    … …  
    152159
    153160    EVENT_BUTTON_PRESS = gdk.EventType.BUTTON_PRESS
     161
     162    TREE_VIEW_COLUMN_FIXED = gtk.TreeViewColumnSizing.FIXED
     163
     164    FILL = gtk.AttachOptions.FILL
     165    EXPAND = gtk.AttachOptions.EXPAND
    154166
    155167    pixbuf_new_from_file = gdkPixbuf.Pixbuf.new_from_file
    … …  
    286298                  _const.AIRCRAFT_T134  : xstr("aircraft_t134"),
    287299                  _const.AIRCRAFT_T154  : xstr("aircraft_t154"),
    288                   _const.AIRCRAFT_YK40  : xstr("aircraft_yk40") }
     300                  _const.AIRCRAFT_YK40  : xstr("aircraft_yk40"),
     301                  _const.AIRCRAFT_B462  : xstr("aircraft_b462") }
    289302
    290303#------------------------------------------------------------------------------

  • src/mlx/gui/flight.py

    r413 r436  
    368368    def _loginClicked(self, button):
    369369        """Called when the login button was clicked."""
    370         print "mlx.flight.LoginPage: logged in"
     370        print "mlx.flight.LoginPage: logging in"
    371371        self._wizard.login(self._handleLoginResult,
    372372                           self._pilotID.get_text(),
    … …  
    591591        flight = self._getSelectedFlight()
    592592        self._wizard._bookedFlight = flight
    593         self._wizard.gui.enableFlightInfo()
     593        self._wizard.gui.enableFlightInfo(flight.aircraftType)
    594594
    595595        self._updateDepartureGate()

  • src/mlx/gui/gui.py

    r430 r450  
    493493            self.reset()
    494494
    495     def enableFlightInfo(self):
     495    def enableFlightInfo(self, aircraftType):
    496496        """Enable the flight info tab."""
    497         self._flightInfo.enable()
     497        self._flightInfo.enable(aircraftType)
    498498
    499499    def cancelFlight(self):

  • src/mlx/gui/info.py

    r349 r441  
    11
    22from common import *
     3
     4from mlx.gui.delaycodes import DelayCodeTable
    35
    46from mlx.i18n import xstr
    … …  
    2123    """The flight info tab."""
    2224    @staticmethod
    23     def _delayCodes():
    24         """Get an array of delay codes."""
    25         return [ (const.DELAYCODE_LOADING, xstr("info_delay_loading")),
    26                  (const.DELAYCODE_VATSIM, xstr("info_delay_vatsim")),
    27                  (const.DELAYCODE_NETWORK, xstr("info_delay_net")),
    28                  (const.DELAYCODE_CONTROLLER, xstr("info_delay_atc")),
    29                  (const.DELAYCODE_SYSTEM, xstr("info_delay_system")),
    30                  (const.DELAYCODE_NAVIGATION, xstr("info_delay_nav")),
    31                  (const.DELAYCODE_TRAFFIC, xstr("info_delay_traffic")),
    32                  (const.DELAYCODE_APRON, xstr("info_delay_apron")),
    33                  (const.DELAYCODE_WEATHER, xstr("info_delay_weather")),
    34                  (const.DELAYCODE_PERSONAL, xstr("info_delay_personal")) ]
    35 
    36     @staticmethod
    3725    def _createCommentArea(label):
    3826        """Create a comment area.
    … …  
    5240
    5341        scroller = gtk.ScrolledWindow()
    54         # FIXME: these should be constants
    55         scroller.set_policy(gtk.PolicyType.AUTOMATIC if pygobject
    56                             else gtk.POLICY_AUTOMATIC,
    57                             gtk.PolicyType.AUTOMATIC if pygobject
    58                             else gtk.POLICY_AUTOMATIC)
    59         scroller.set_shadow_type(gtk.ShadowType.IN if pygobject
    60                                  else gtk.SHADOW_IN)
     42        scroller.set_policy(POLICY_AUTOMATIC, POLICY_AUTOMATIC)
     43        scroller.set_shadow_type(SHADOW_IN)
     44
    6145        comments = gtk.TextView()
    6246        comments.set_wrap_mode(WRAP_WORD)
    … …  
    9478
    9579        alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
    96                                   xscale = 0.0, yscale = 0.0)
     80                                  xscale = 1.0, yscale = 1.0)
    9781        alignment.set_padding(padding_top = 4, padding_bottom = 4,
    9882                              padding_left = 8, padding_right = 8)
    9983
    100         self._delayTable = table = gtk.Table(5, 2)
    101         table.set_col_spacings(16)
     84        self._delayCodeTable = table = DelayCodeTable()
     85        self._delayWindow = scrolledWindow = gtk.ScrolledWindow()
     86        scrolledWindow.add(table)
     87        scrolledWindow.set_size_request(-1, 185)
     88        scrolledWindow.set_policy(POLICY_AUTOMATIC, POLICY_AUTOMATIC)
     89        scrolledWindow.set_shadow_type(SHADOW_IN)
    10290
    103         row = 0
    104         column = 0
    105 
    106         self._delayCodeWidgets = []
    107         for (_code, label) in FlightInfo._delayCodes():
    108             button = gtk.CheckButton(label)
    109             button.set_use_underline(True)
    110             table.attach(button, column, column + 1, row, row + 1)
    111             self._delayCodeWidgets.append(button)
    112             if column==0:
    113                 column += 1
    114             else:
    115                 row += 1
    116                 column = 0
    117 
    118         alignment.add(table)
     91        alignment.add(scrolledWindow)
    11992        frame.add(alignment)
    12093
    12194        self._delayAlignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
    122                                              xscale = 0.0, yscale = 0.0)
     95                                             xscale = 1.0, yscale = 1.0)
    12396        self._delayAlignment.add(frame)
     97        self._delayAlignment.set_padding(padding_top = 0, padding_bottom = 0,
     98                                         padding_left = 8, padding_right = 8)
    12499
    125100        self.pack_start(self._delayAlignment, False, False, 8)
    … …  
    147122    def delayCodes(self):
    148123        """Get the list of delay codes checked by the user."""
    149         codes =  []
    150         delayCodes = FlightInfo._delayCodes()
    151         for index in range(0, len(delayCodes)):
    152             if self._delayCodeWidgets[index].get_active():
    153                 codes.append(delayCodes[index][0])
    154         return codes
     124        return self._delayCodeTable.delayCodes
    155125
    156     def enable(self):
     126    def enable(self, aircraftType):
    157127        """Enable the flight info tab."""
    158128        self._comments.set_sensitive(True)
    159129        self._flightDefects.set_sensitive(True)
    160         self._delayTable.set_sensitive(True)
     130        self._delayCodeTable.setType(aircraftType)
     131        self._delayWindow.set_sensitive(True)
     132        self._delayCodeTable.setStyle()
    161133
    162134    def disable(self):
    … …  
    164136        self._comments.set_sensitive(False)
    165137        self._flightDefects.set_sensitive(False)
    166         self._delayTable.set_sensitive(False)
     138        self._delayWindow.set_sensitive(False)
     139        self._delayCodeTable.setStyle()
    167140
    168141    def reset(self):
    … …  
    170143        self._comments.get_buffer().set_text("")
    171144        self._flightDefects.get_buffer().set_text("")
    172 
    173         for widget in self._delayCodeWidgets:
    174             widget.set_active(False)
     145        self._delayCodeTable.reset()
    175146
    176147    def _commentsChanged(self, textbuffer):

  • src/mlx/gui/pirep.py

    r303 r437  
    241241        for code in pirep.delayCodes:
    242242            if delayCodes: delayCodes += ", "
    243             delayCodes += PIREP.delayCodeNames[code]
     243            delayCodes += code
    244244       
    245245        self._delayCodes.get_buffer().set_text(delayCodes)       

  • src/mlx/pirep.py

    r401 r437  
    1919class PIREP(object):
    2020    """A pilot's report of a flight."""
    21     delayCodeNames = { const.DELAYCODE_LOADING : "Loading Problems",
    22                        const.DELAYCODE_NETWORK : "Net Problems",
    23                        const.DELAYCODE_SYSTEM : "System Crash/Freezing",
    24                        const.DELAYCODE_TRAFFIC : "Traffic Problems",
    25                        const.DELAYCODE_WEATHER : "Weather Problems",
    26                        const.DELAYCODE_VATSIM : "VATSIM Problem",
    27                        const.DELAYCODE_CONTROLLER : "Controller's Fault",
    28                        const.DELAYCODE_NAVIGATION : "Navigation Problem",
    29                        const.DELAYCODE_APRON : "Apron Navigation Problems",
    30                        const.DELAYCODE_PERSONAL : "Personal Reasons" }
    31 
    3221    @staticmethod
    3322    def _formatLine(timeStr, line):
    … …  
    140129            for code in self.delayCodes:
    141130                if s: s += ", "
    142                 s += PIREP.delayCodeNames[code]
     131                s += code
    143132            return s
    144133

  • src/mlx/pyuipc_sim.py

    r408 r443  
    158158    ENGINE_3 = 2
    159159
     160    ## Engine index: engine #4
     161    ENGINE_4 = 3
     162
    160163    ## The number of hotkey entries
    161164    HOTKEY_SIZE = 56
    … …  
    295298        self.visibility = 10000
    296299
    297         self.n1 = [0.0, 0.0, 0.0]
    298         self.throttles = [0.0, 0.0, 0.0]
     300        self.n1 = [0.0, 0.0, 0.0, 0.0]
     301        self.throttles = [0.0, 0.0, 0.0, 0.0]
    299302
    300303        self.payloadCount = 1
    … …  
    328331        self.eng2DeIce = False
    329332        self.eng3DeIce = False
     333        self.eng4DeIce = False
    330334        self.propDeIce = False
    331335        self.structDeIce = False
    … …  
    427431        elif offset==0x09e2:       # Engine #3 de-ice
    428432            return 1 if self.eng3DeIce else 0
     433        elif offset==0x0a54:       # Engine #4 throttle
     434            return self._getThrottle(self.ENGINE_4)
     435        elif offset==0x0a7a:       # Engine #4 de-ice
     436            return 1 if self.eng4DeIce else 0
    429437        elif offset==0x0af4:       # Fuel weight
    430438            return int(self.fuelWeight * 256.0)
    … …  
    533541            return self.n1[self.ENGINE_2]
    534542        elif offset==0x2200:       # Engine #3 N1
     543            return self.n1[self.ENGINE_3]
     544        elif offset==0x2300:       # Engine #4 N1
    535545            return self.n1[self.ENGINE_3]
    536546        elif offset==0x2ea0:       # Elevator trim
    … …  
    695705        elif offset==0x09e2:       # Engine #3 de-ice
    696706            self.eng3DeIce = value!=0
     707        elif offset==0x0a54:       # Engine #4 throttle
     708            self._setThrottle(self.ENGINE_4, value)
     709        elif offset==0x0a7a:       # Engine #4 de-ice
     710            self.eng4DeIce = value!=0
    697711        elif offset==0x0af4:       # Fuel weight
    698712            self.fuelWeight = value / 256.0
    … …  
    796810        elif offset==0x2200:       # Engine #3 N1
    797811            self.n1[self.ENGINE_3] = value
     812        elif offset==0x2300:       # Engine #4 N1
     813            self.n1[self.ENGINE_4] = value
    798814        elif offset==0x2ea0:       # Elevator trim
    799815            self.elevatorTrim = value * 180.0 / math.pi
    … …  
    14131429        self._valueHandlers["n1_3"] = ([(0x2200, "f")], lambda value: value,
    14141430                                       lambda word: float(word))
     1431        self._valueHandlers["n1_4"] = ([(0x2300, "f")], lambda value: value,
     1432                                       lambda word: float(word))
    14151433
    14161434        self._valueHandlers["throttle_1"] = ([(0x088c, "H")],
    … …  
    14211439                                             CLI.throttle2pyuipc)
    14221440        self._valueHandlers["throttle_3"] = ([(0x09bc, "H")],
     1441                                             CLI.pyuipc2throttle,
     1442                                             CLI.throttle2pyuipc)
     1443        self._valueHandlers["throttle_4"] = ([(0x0a54, "H")],
    14231444                                             CLI.pyuipc2throttle,
    14241445                                             CLI.throttle2pyuipc)
    … …  
    14901511                                            CLI.bool2str, CLI.str2bool)
    14911512        self._valueHandlers["eng3Deice"] = ([(0x09e2, "H")],
     1513                                            CLI.bool2str, CLI.str2bool)
     1514        self._valueHandlers["eng4Deice"] = ([(0x0a7a, "H")],
    14921515                                            CLI.bool2str, CLI.str2bool)
    14931516        self._valueHandlers["propDeice"] = ([(0x337c, "b")],

  • src/mlx/web.py

    r430 r450  
    6363                      "TU3"  : const.AIRCRAFT_T134,
    6464                      "TU5"  : const.AIRCRAFT_T154,
    65                       "YK4"  : const.AIRCRAFT_YK40 }
     65                      "YK4"  : const.AIRCRAFT_YK40,
     66                      "146"  : const.AIRCRAFT_B462 }
    6667
    6768    TYPE2TYPECODE = { const.AIRCRAFT_B736  : "736",
    … …  
    8081                      const.AIRCRAFT_T134  : "TU3",
    8182                      const.AIRCRAFT_T154  : "TU5",
    82                       const.AIRCRAFT_YK40  : "YK4" }
     83                      const.AIRCRAFT_YK40  : "YK4",
     84                      const.AIRCRAFT_B462  : "146" }
    8385
    8486    @staticmethod
Note: See TracChangeset for help on using the changeset viewer.