Changeset 833:f300ebc45a7f

Timestamp:

04/15/17 12:32:05 (8 years ago)

Author:

István Váradi <ivaradi@…>

Branch:

default

Phase:

public

Message:

All data is displayed and is editable in the PIREP editor (re #307)

Files:

• locale/en/mlx.po (modified) (1 diff)
• locale/hu/mlx.po (modified) (1 diff)
• src/mlx/const.py (modified) (1 diff)
• src/mlx/gui/common.py (modified) (3 diffs)
• src/mlx/gui/delaycodes.py (modified) (1 diff)
• src/mlx/gui/faultexplain.py (modified) (3 diffs)
• src/mlx/gui/flight.py (modified) (2 diffs)
• src/mlx/gui/gui.py (modified) (3 diffs)
• src/mlx/gui/info.py (modified) (4 diffs)
• src/mlx/gui/pirep.py (modified) (9 diffs)
• src/mlx/pirep.py (modified) (2 diffs)

locale/en/mlx.po

@@ -2046 +2046 @@
 msgid "pirepView_tab_log_tooltip"
 msgstr "The flight log."
+
+msgid "pirepEdit_title"
+msgstr "PIREP editor"
+
+msgid "pirepEdit_FL"
+msgstr "  FL"
 
 msgid "about_website"

locale/hu/mlx.po

@@ -2061 +2061 @@
 msgid "pirepView_tab_log_tooltip"
 msgstr "A repülési napló."
+
+msgid "pirepEdit_title"
+msgstr "PIREP szerkesztése"
 
 msgid "about_website"

src/mlx/const.py

@@ -247 +247 @@
            if flightType in _flightTypeStrings else None
 
+def flightType2index(flightType):
+    """Get the index of the given flight type according to the list above"""
+    return flightTypes.index(flightType)
+
 #-------------------------------------------------------------------------------
 

src/mlx/gui/common.py

@@ -8 +8 @@
 
 import os
+import time
 
 #-----------------------------------------------------------------------------
@@ -283 +284 @@
                       else str(self._currentInteger))
         self._selfSetting = False
+
+#------------------------------------------------------------------------------
+
+class TimeEntry(gtk.Entry):
+    """Widget to display and edit a time value in HH:MM format."""
+    def __init__(self):
+        """Construct the entry"""
+        super(TimeEntry, self).__init__(max = 5)
+
+        self.connect("insert-text", self._insertText)
+        self.connect("delete-text", self._deleteText)
+        self.connect("focus-out-event", self._focusOutEvent)
+
+    @property
+    def hour(self):
+        """Get the hour from the current text"""
+        text = self.get_text()
+        if not text or text==":":
+            return 0
+
+        words = text.split(":")
+        if len(words)==1:
+            return 0
+        elif len(words)>=2:
+            return 0 if len(words[0])==0 else int(words[0])
+        else:
+            return 0
+
+    @property
+    def minute(self):
+        """Get the hour from the current text"""
+        text = self.get_text()
+        if not text or text==":":
+            return 0
+
+        words = text.split(":")
+        if len(words)==1:
+            return 0 if len(words[0])==0 else int(words[0])
+        elif len(words)>=2:
+            return 0 if len(words[1])==0 else int(words[1])
+        else:
+            return 0
+
+    def setTimestamp(self, timestamp):
+        """Set the hour and minute from the given timestamp in UTC."""
+        tm = time.gmtime(timestamp)
+        self.set_text("%02d:%02d" % (tm.tm_hour, tm.tm_min))
+
+    def _focusOutEvent(self, widget, event):
+        """Reformat the text to match pattern HH:MM"""
+        text = "%02d:%02d" % (self.hour, self.minute)
+        if text!=self.get_text():
+            self.set_text(text)
+
+    def _insertText(self, entry, text, length, position):
+        """Called when some text is inserted into the entry."""
+        text=text[:length]
+        currentText = self.get_text()
+        position = self.get_position()
+        newText = currentText[:position] + text + currentText[position:]
+        self._checkText(newText, "insert-text")
+
+    def _deleteText(self, entry, start, end):
+        """Called when some text is erased from the entry."""
+        currentText = self.get_text()
+        newText = currentText[:start] + currentText[end:]
+        self._checkText(newText, "delete-text")
+
+    def _checkText(self, newText, signal):
+        """Check the given text.
+
+        If it is not suitable, stop the emission of the signal to prevent the
+        change from appearing."""
+        if not newText or newText==":":
+            return
+
+        words = newText.split(":")
+        if (len(words)==1 and
+            len(words[0])<=2 and (len(words[0])==0 or
+                                  (words[0].isdigit() and int(words[0])<60))) or \
+           (len(words)==2 and
+            len(words[0])<=2 and (len(words[0])==0 or
+                                  (words[0].isdigit() and int(words[0])<24)) and
+            len(words[1])<=2 and (len(words[1])==0 or
+                                  (words[1].isdigit() and int(words[1])<60))):
+            pass
+        else:
+            gtk.gdk.display_get_default().beep()
+            self.stop_emission(signal)
 
 #------------------------------------------------------------------------------
@@ -519 +609 @@
 
 #------------------------------------------------------------------------------
+
+def createFlightTypeComboBox():
+        flightTypeModel = gtk.ListStore(str, int)
+        for type in _const.flightTypes:
+            name = "flighttype_" + _const.flightType2string(type)
+            flightTypeModel.append([xstr(name), type])
+
+        flightType = gtk.ComboBox(model = flightTypeModel)
+        renderer = gtk.CellRendererText()
+        flightType.pack_start(renderer, True)
+        flightType.add_attribute(renderer, "text", 0)
+
+        return flightType
+
+#------------------------------------------------------------------------------

src/mlx/gui/delaycodes.py

@@ -380 +380 @@
         self.show_all()
 
+    def activateCode(self, code):
+        """Check the checkbox for the given code."""
+        index = 0
+        for (type, data) in self._delayCodeData[2]:
+            if type==DELAYCODE:
+                if code==data[0].strip():
+                    self._checkButtons[index].set_active(True)
+                    break
+                index += 1
+
     def _delayCodesChanged(self, button):
         """Called when one of the delay codes have changed."""

src/mlx/gui/faultexplain.py

@@ -94 +94 @@
                                buffer.get_end_iter(), True)
 
+    @explanation.setter
+    def explanation(self, explanation):
+        """Set the explanation."""
+        self._explanation.get_buffer().set_text(explanation)
+
     @property
     def hasExplanation(self):
@@ -126 +131 @@
 
 class FaultExplainWidget(gtk.Frame):
-    """The widget for the failts and their explanations."""
+    """The widget for the faults and their explanations."""
     @staticmethod
     def getFaultFrame(alignment):
@@ -235 +240 @@
                           numExplanations = self._numExplanations -
                           (1 if hasExplanation else 0))
+
+    def setExplanation(self, id, explanation):
+        """Set the explanation for the fault with the given ID"""
+        self._faultWidgets[id][1].explanation = explanation
 
     def reset(self):

src/mlx/gui/flight.py

@@ -4521 +4521 @@
 class FinishPage(Page):
     """Flight finish page."""
-    _flightTypes = [ ("flighttype_scheduled", const.FLIGHTTYPE_SCHEDULED),
-                     ("flighttype_ot", const.FLIGHTTYPE_OLDTIMER),
-                     ("flighttype_vip", const.FLIGHTTYPE_VIP),
-                     ("flighttype_charter", const.FLIGHTTYPE_CHARTER) ]
-
     def __init__(self, wizard, saveHelper):
         """Construct the finish page."""
@@ -4658 +4653 @@
         table.attach(labelAlignment, 0, 1, row, row+1)
 
-        flightTypeModel = gtk.ListStore(str, int)
-        for (name, type) in FinishPage._flightTypes:
-            flightTypeModel.append([xstr(name), type])
-
-        self._flightType = gtk.ComboBox(model = flightTypeModel)
-        renderer = gtk.CellRendererText()
-        self._flightType.pack_start(renderer, True)
-        self._flightType.add_attribute(renderer, "text", 0)
+        self._flightType = createFlightTypeComboBox()
         self._flightType.set_tooltip_text(xstr("finish_type_tooltip"))
         self._flightType.set_active(0)

src/mlx/gui/gui.py

@@ -13 +13 @@
 from mlx.gui.checklist import ChecklistEditor
 from mlx.gui.callouts import ApproachCalloutsEditor
-from mlx.gui.pirep import PIREPViewer
+from mlx.gui.pirep import PIREPViewer, PIREPEditor
 from mlx.gui.bugreport import BugReportDialog
 from mlx.gui.acars import ACARS
@@ -183 +183 @@
 
         self._pirepViewer = PIREPViewer(self)
+
+        self._pirepEditor = PIREPEditor(self)
 
         window.show_all()
@@ -1262 +1264 @@
     def editPIREP(self, pirep):
         """Display the PIREP editor window and allow editing the PIREP."""
-        self.viewPIREP(pirep)
+        self._pirepEditor.setPIREP(pirep)
+        self._pirepEditor.show_all()
+        self._pirepEditor.run()
+        self._pirepEditor.hide()
 
     def _loadPIREP(self, menuItem):

src/mlx/gui/info.py

@@ -54 +54 @@
         return (frame, comments)
 
-    def __init__(self, gui):
+    def __init__(self, gui, mainInstance = True):
         """Construct the flight info tab."""
         super(FlightInfo, self).__init__()
         self._gui = gui
+        self._mainInstance = mainInstance
 
         self._commentsAlignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
@@ -110 +111 @@
                                             buffer.get_end_iter(), True))
 
+    @comments.setter
+    def comments(self, comments):
+        """Set the comments."""
+        self._comments.get_buffer().set_text(comments)
+
     @property
     def hasComments(self):
@@ -147 +153 @@
         self._faultExplainWidget.clearFault(id)
 
+    def setExplanation(self, id, explanation):
+        """Set the explanation of the given fault."""
+        self._faultExplainWidget.setExplanation(id, explanation)
+
     def enable(self, aircraftType):
         """Enable the flight info tab."""
@@ -168 +178 @@
         self._delayCodeTable.reset()
 
+    def activateDelayCode(self, code):
+        """Active the checkbox corresponding to the given code."""
+        self._delayCodeTable.activateCode(code)
+
     def delayCodesChanged(self):
         """Callewd when the delay codes have changed."""
-        self._gui.delayCodesChanged()
+        if self._mainInstance:
+            self._gui.delayCodesChanged()
 
     def _commentsChanged(self, textbuffer):
         """Called when the comments have changed."""
-        self._gui.commentsChanged()
+        if self._mainInstance:
+            self._gui.commentsChanged()
 
     def _faultExplanationsChanged(self, faultExplainWidget, fullyExplained):
         """Called when the status of the fault explanations has changed."""
-        self._gui.faultExplanationsChanged()
+        if self._mainInstance:
+            self._gui.faultExplanationsChanged()

src/mlx/gui/pirep.py

@@ -1 +1 @@
 
 from common import *
+from dcdata import getTable
+from info import FlightInfo
+from flight import comboModel
 
 from mlx.pirep import PIREP
@@ -6 +9 @@
 
 import time
+import re
 
 #------------------------------------------------------------------------------
@@ -11 +15 @@
 ## @package mlx.gui.pirep
 #
-# The detailed PIREP viewer.
+# The detailed PIREP viewer and editor windows.
 #
 # The \ref PIREPViewer class is a dialog displaying all information found in a
@@ -47 +51 @@
 
     @staticmethod
-    def getLabel(text):
+    def getLabel(text, extraText = ""):
         """Get a bold label with the given text."""
-        label = gtk.Label("<b>" + text + "</b>")
+        label = gtk.Label("<b>" + text + "</b>" + extraText)
         label.set_use_markup(True)
         label.set_alignment(0.0, 0.5)
@@ -64 +68 @@
 
     @staticmethod
-    def getTextWindow(heightRequest = 40):
+    def getTextWindow(heightRequest = 40, editable = False):
         """Get a scrollable text window.
 
@@ -76 +80 @@
         textView = gtk.TextView()
         textView.set_wrap_mode(WRAP_WORD)
-        textView.set_editable(False)
-        textView.set_cursor_visible(False)
+        textView.set_editable(editable)
+        textView.set_cursor_visible(editable)
         textView.set_size_request(-1, heightRequest)
         scrolledWindow.add(textView)
@@ -106 +110 @@
         """Add a label and a data label to the given HBox.
 
-        Returnsd the data label."""
+        Returns the data label."""
         label = PIREPViewer.getLabel(labelText)
         hBox.pack_start(label, False, False, 0)
@@ -114 +118 @@
 
         return dataLabel
+
+    @staticmethod
+    def addHFiller(hBox, width = 8):
+        """Add a filler to the given horizontal box."""
+        filler = gtk.Alignment(xalign = 0.0, yalign = 0.0,
+                               xscale = 1.0, yscale = 1.0)
+        filler.set_size_request(width, -1)
+        hBox.pack_start(filler, False, False, 0)
 
     @staticmethod
@@ -615 +627 @@
 
 #------------------------------------------------------------------------------
+
+class PIREPEditor(gtk.Dialog):
+    """A PIREP editor dialog."""
+    _delayCodeRE = re.compile("([0-9]{2,3})( \([^\)]*\))")
+
+    @staticmethod
+    def tableAttachWidget(table, column, row, labelText, widget):
+        """Attach the given widget with the given label to the given table.
+
+        The label will got to cell (column, row), the widget to cell
+        (column+1, row)."""
+        label = gtk.Label("<b>" + labelText + "</b>")
+        label.set_use_markup(True)
+        alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
+                                  xscale = 0.0, yscale = 0.0)
+        alignment.add(label)
+        table.attach(alignment, column, column + 1, row, row + 1)
+
+        table.attach(widget, column + 1, column + 2, row, row + 1)
+
+    @staticmethod
+    def tableAttachSpinButton(table, column, row, labelText, maxValue,
+                              minValue = 0, stepIncrement = 1,
+                              pageIncrement = 10, numeric = True,
+                              width = 3):
+        """Attach a spin button with the given label to the given table.
+
+        The label will got to cell (column, row), the spin button to cell
+        (column+1, row)."""
+        button = gtk.SpinButton()
+        button.set_range(min = minValue, max = maxValue)
+        button.set_increments(step = stepIncrement, page = pageIncrement)
+        button.set_numeric(True)
+        button.set_width_chars(width)
+        button.set_alignment(1.0)
+
+        PIREPEditor.tableAttachWidget(table, column, row, labelText, button)
+
+        return button
+
+    @staticmethod
+    def tableAttachTimeEntry(table, column, row, labelText):
+        """Attach a time entry widget with the given label to the given table.
+
+        The label will got to cell (column, row), the spin button to cell
+        (column+1, row)."""
+        entry = TimeEntry()
+        entry.set_width_chars(5)
+        entry.set_alignment(1.0)
+
+        PIREPEditor.tableAttachWidget(table, column, row, labelText, entry)
+
+        return entry
+
+    def __init__(self, gui):
+        """Construct the PIREP viewer."""
+        super(PIREPEditor, self).__init__(title = WINDOW_TITLE_BASE +
+                                          " - " +
+                                          xstr("pirepEdit_title"),
+                                          parent = gui.mainWindow)
+
+        self.set_resizable(False)
+
+        self._gui = gui
+
+        contentArea = self.get_content_area()
+
+        self._notebook = gtk.Notebook()
+        contentArea.pack_start(self._notebook, False, False, 4)
+
+        dataTab = self._buildDataTab()
+        label = gtk.Label(xstr("pirepView_tab_data"))
+        label.set_use_underline(True)
+        label.set_tooltip_text(xstr("pirepView_tab_data_tooltip"))
+        self._notebook.append_page(dataTab, label)
+
+        self._flightInfo = self._buildCommentsTab()
+        label = gtk.Label(xstr("pirepView_tab_comments"))
+        label.set_use_underline(True)
+        label.set_tooltip_text(xstr("pirepView_tab_comments_tooltip"))
+        self._notebook.append_page(self._flightInfo, label)
+
+        logTab = self._buildLogTab()
+        label = gtk.Label(xstr("pirepView_tab_log"))
+        label.set_use_underline(True)
+        label.set_tooltip_text(xstr("pirepView_tab_log_tooltip"))
+        self._notebook.append_page(logTab, label)
+
+        self._okButton = self.add_button(xstr("button_ok"), RESPONSETYPE_OK)
+        self._okButton.set_can_default(True)
+
+    def setPIREP(self, pirep):
+        """Setup the data in the dialog from the given PIREP."""
+        bookedFlight = pirep.bookedFlight
+
+        self._callsign.set_text(bookedFlight.callsign)
+        self._tailNumber.set_text(bookedFlight.tailNumber)
+        aircraftType = xstr("aircraft_" + icaoCodes[bookedFlight.aircraftType].lower())
+        self._aircraftType.set_text(aircraftType)
+
+        self._departureICAO.set_text(bookedFlight.departureICAO)
+        self._departureTime.set_text("%02d:%02d" % \
+                                     (bookedFlight.departureTime.hour,
+                                      bookedFlight.departureTime.minute))
+
+        self._arrivalICAO.set_text(bookedFlight.arrivalICAO)
+        self._arrivalTime.set_text("%02d:%02d" % \
+                                   (bookedFlight.arrivalTime.hour,
+                                    bookedFlight.arrivalTime.minute))
+
+        self._numPassengers.set_text(str(bookedFlight.numPassengers))
+        self._numCrew.set_text(str(bookedFlight.numCrew))
+        self._bagWeight.set_text(str(bookedFlight.bagWeight))
+        self._cargoWeight.set_text(str(bookedFlight.cargoWeight))
+        self._mailWeight.set_text(str(bookedFlight.mailWeight))
+
+        self._route.get_buffer().set_text(bookedFlight.route)
+
+        self._filedCruiseLevel.set_value(pirep.filedCruiseAltitude/100)
+        self._modifiedCruiseLevel.set_value(pirep.cruiseAltitude/100)
+
+        self._userRoute.get_buffer().set_text(pirep.route)
+
+        self._departureMETAR.get_buffer().set_text(pirep.departureMETAR)
+
+        self._arrivalMETAR.get_buffer().set_text(pirep.arrivalMETAR)
+        self._departureRunway.set_text(pirep.departureRunway)
+        self._sid.get_child().set_text(pirep.sid)
+
+        if not pirep.star:
+            self._star.set_active(0)
+        else:
+            self._star.get_child().set_text(pirep.star)
+
+        if not pirep.transition:
+            self._transition.set_active(0)
+        else:
+            self._transition.get_child().set_text(pirep.transition)
+        self._approachType.set_text(pirep.approachType)
+        self._arrivalRunway.set_text(pirep.arrivalRunway)
+
+        self._blockTimeStart.setTimestamp(pirep.blockTimeStart)
+        self._blockTimeEnd.setTimestamp(pirep.blockTimeEnd)
+        self._flightTimeStart.setTimestamp(pirep.flightTimeStart)
+        self._flightTimeEnd.setTimestamp(pirep.flightTimeEnd)
+
+        self._flownDistance.set_text("%.1f" % (pirep.flownDistance,))
+        self._fuelUsed.set_value(int(pirep.fuelUsed))
+
+        rating = pirep.rating
+        if rating<0:
+            self._rating.set_markup('<b><span foreground="red">NO GO</span></b>')
+        else:
+            self._rating.set_text("%.1f %%" % (rating,))
+
+        self._flownNumCrew.set_value(pirep.numCrew)
+        self._flownNumPassengers.set_value(pirep.numPassengers)
+        self._flownBagWeight.set_value(pirep.bagWeight)
+        self._flownCargoWeight.set_value(pirep.cargoWeight)
+        self._flownMailWeight.set_value(pirep.mailWeight)
+        self._flightType.set_active(flightType2index(pirep.flightType))
+        self._online.set_active(pirep.online)
+
+        self._flightInfo.reset()
+        self._flightInfo.enable(bookedFlight.aircraftType)
+
+        delayCodes = ""
+        for code in pirep.delayCodes:
+            if delayCodes: delayCodes += ", "
+            delayCodes += code
+            m = PIREPEditor._delayCodeRE.match(code)
+            if m:
+                self._flightInfo.activateDelayCode(m.group(1))
+
+        self._delayCodes.get_buffer().set_text(delayCodes)
+
+        self._flightInfo.comments = pirep.comments
+        if pirep.flightDefects.find("<br/></b>")!=-1:
+            flightDefects = pirep.flightDefects.split("<br/></b>")
+            caption = flightDefects[0]
+            index = 0
+            for defect in flightDefects[1:]:
+                if defect.find("<b>")!=-1:
+                    (explanation, nextCaption) = defect.split("<b>")
+                else:
+                    explanation = defect
+                    nextCaption = None
+                self._flightInfo.addFault(index, caption)
+                self._flightInfo.setExplanation(index, explanation)
+                index += 1
+                caption = nextCaption
+
+        # self._comments.get_buffer().set_text(pirep.comments)
+        # self._flightDefects.get_buffer().set_text(pirep.flightDefects)
+
+        logBuffer = self._log.get_buffer()
+        logBuffer.set_text("")
+        lineIndex = 0
+        for (timeStr, line) in pirep.logLines:
+            isFault = lineIndex in pirep.faultLineIndexes
+            appendTextBuffer(logBuffer,
+                             formatFlightLogLine(timeStr, line),
+                             isFault = isFault)
+            lineIndex += 1
+
+        self._notebook.set_current_page(0)
+        self._okButton.grab_default()
+
+    def _buildDataTab(self):
+        """Build the data tab of the viewer."""
+        table = gtk.Table(1, 2)
+        table.set_row_spacings(4)
+        table.set_col_spacings(16)
+        table.set_homogeneous(True)
+
+        box1 = gtk.VBox()
+        table.attach(box1, 0, 1, 0, 1)
+
+        box2 = gtk.VBox()
+        table.attach(box2, 1, 2, 0, 1)
+
+        flightFrame = self._buildFlightFrame()
+        box1.pack_start(flightFrame, False, False, 4)
+
+        routeFrame = self._buildRouteFrame()
+        box1.pack_start(routeFrame, False, False, 4)
+
+        departureFrame = self._buildDepartureFrame()
+        box2.pack_start(departureFrame, True, True, 4)
+
+        arrivalFrame = self._buildArrivalFrame()
+        box2.pack_start(arrivalFrame, True, True, 4)
+
+        statisticsFrame = self._buildStatisticsFrame()
+        box2.pack_start(statisticsFrame, False, False, 4)
+
+        miscellaneousFrame = self._buildMiscellaneousFrame()
+        box1.pack_start(miscellaneousFrame, False, False, 4)
+
+        return table
+
+    def _buildFlightFrame(self):
+        """Build the frame for the flight data."""
+
+        (frame, mainBox) = PIREPViewer.createFrame(xstr("pirepView_frame_flight"))
+
+        dataBox = gtk.HBox()
+        mainBox.pack_start(dataBox, False, False, 0)
+
+        self._callsign = \
+            PIREPViewer.addLabeledData(dataBox,
+                                       xstr("pirepView_callsign"),
+                                       width = 8)
+
+        self._tailNumber = \
+            PIREPViewer.addLabeledData(dataBox,
+                                       xstr("pirepView_tailNumber"),
+                                       width = 7)
+
+        PIREPViewer.addVFiller(mainBox)
+
+        dataBox = gtk.HBox()
+        mainBox.pack_start(dataBox, False, False, 0)
+
+        self._aircraftType = \
+            PIREPViewer.addLabeledData(dataBox,
+                                       xstr("pirepView_aircraftType"),
+                                       width = 25)
+
+        PIREPViewer.addVFiller(mainBox)
+
+        table = gtk.Table(3, 2)
+        mainBox.pack_start(table, False, False, 0)
+        table.set_row_spacings(4)
+        table.set_col_spacings(8)
+
+        self._departureICAO = \
+            PIREPViewer.tableAttach(table, 0, 0,
+                                    xstr("pirepView_departure"),
+                                    width = 5)
+
+        self._departureTime = \
+            PIREPViewer.tableAttach(table, 1, 0,
+                                    xstr("pirepView_departure_time"),
+                                    width = 6)
+
+        self._arrivalICAO = \
+            PIREPViewer.tableAttach(table, 0, 1,
+                                    xstr("pirepView_arrival"),
+                                    width = 5)
+
+        self._arrivalTime = \
+            PIREPViewer.tableAttach(table, 1, 1,
+                                    xstr("pirepView_arrival_time"),
+                                    width = 6)
+
+        table = gtk.Table(3, 2)
+        mainBox.pack_start(table, False, False, 0)
+        table.set_row_spacings(4)
+        table.set_col_spacings(8)
+
+        self._numPassengers = \
+            PIREPViewer.tableAttach(table, 0, 0,
+                                    xstr("pirepView_numPassengers"),
+                                    width = 4)
+
+        self._numCrew = \
+            PIREPViewer.tableAttach(table, 1, 0,
+                                    xstr("pirepView_numCrew"),
+                                    width = 3)
+
+        self._bagWeight = \
+            PIREPViewer.tableAttach(table, 0, 1,
+                                    xstr("pirepView_bagWeight"),
+                                    width = 5)
+
+        self._cargoWeight = \
+            PIREPViewer.tableAttach(table, 1, 1,
+                                    xstr("pirepView_cargoWeight"),
+                                    width = 5)
+
+        self._mailWeight = \
+            PIREPViewer.tableAttach(table, 2, 1,
+                                    xstr("pirepView_mailWeight"),
+                                    width = 5)
+
+        PIREPViewer.addVFiller(mainBox)
+
+        mainBox.pack_start(PIREPViewer.getLabel(xstr("pirepView_route")),
+                           False, False, 0)
+
+        (routeWindow, self._route) = PIREPViewer.getTextWindow()
+        mainBox.pack_start(routeWindow, False, False, 0)
+
+        return frame
+
+    def _buildRouteFrame(self):
+        """Build the frame for the user-specified route and flight
+        level."""
+
+        (frame, mainBox) = PIREPViewer.createFrame(xstr("pirepView_frame_route"))
+
+        levelBox = gtk.HBox()
+        mainBox.pack_start(levelBox, False, False, 0)
+
+        label = PIREPViewer.getLabel(xstr("pirepView_filedCruiseLevel"),
+                                     xstr("pirepEdit_FL"))
+        levelBox.pack_start(label, False, False, 0)
+
+        self._filedCruiseLevel = gtk.SpinButton()
+        self._filedCruiseLevel.set_increments(step = 10, page = 100)
+        self._filedCruiseLevel.set_range(min = 0, max = 500)
+        #self._filedCruiseLevel.set_tooltip_text(xstr("route_level_tooltip"))
+        self._filedCruiseLevel.set_numeric(True)
+
+        levelBox.pack_start(self._filedCruiseLevel, False, False, 0)
+
+        PIREPViewer.addHFiller(levelBox)
+
+        label = PIREPViewer.getLabel(xstr("pirepView_modifiedCruiseLevel"),
+                                     xstr("pirepEdit_FL"))
+        levelBox.pack_start(label, False, False, 0)
+
+        self._modifiedCruiseLevel = gtk.SpinButton()
+        self._modifiedCruiseLevel.set_increments(step = 10, page = 100)
+        self._modifiedCruiseLevel.set_range(min = 0, max = 500)
+        #self._modifiedCruiseLevel.set_tooltip_text(xstr("route_level_tooltip"))
+        self._modifiedCruiseLevel.set_numeric(True)
+
+        levelBox.pack_start(self._modifiedCruiseLevel, False, False, 0)
+
+        PIREPViewer.addVFiller(mainBox)
+
+        (routeWindow, self._userRoute) = \
+          PIREPViewer.getTextWindow(editable = True)
+        mainBox.pack_start(routeWindow, False, False, 0)
+
+        return frame
+
+    def _buildDepartureFrame(self):
+        """Build the frame for the departure data."""
+        (frame, mainBox) = PIREPViewer.createFrame(xstr("pirepView_frame_departure"))
+
+        mainBox.pack_start(PIREPViewer.getLabel("METAR:"),
+                           False, False, 0)
+        (metarWindow, self._departureMETAR) = \
+            PIREPViewer.getTextWindow(heightRequest = -1,
+                                      editable = True)
+        mainBox.pack_start(metarWindow, True, True, 0)
+
+        PIREPViewer.addVFiller(mainBox)
+
+        dataBox = gtk.HBox()
+        mainBox.pack_start(dataBox, False, False, 0)
+
+        label = gtk.Label("<b>" + xstr("pirepView_runway") + "</b>")
+        label.set_use_markup(True)
+        dataBox.pack_start(label, False, False, 0)
+
+        # FIXME: quite the same as the runway entry boxes in the wizard
+        self._departureRunway = gtk.Entry()
+        self._departureRunway.set_width_chars(5)
+        self._departureRunway.set_tooltip_text(xstr("takeoff_runway_tooltip"))
+        self._departureRunway.connect("changed", self._upperChanged)
+        dataBox.pack_start(self._departureRunway, False, False, 8)
+
+        label = gtk.Label("<b>" + xstr("pirepView_sid") + "</b>")
+        label.set_use_markup(True)
+        dataBox.pack_start(label, False, False, 0)
+
+        # FIXME: quite the same as the SID combo box in
+        # the flight wizard
+        if pygobject:
+            self._sid = gtk.ComboBox.new_with_model_and_entry(comboModel)
+        else:
+            self._sid = gtk.ComboBoxEntry(comboModel)
+
+        self._sid.set_entry_text_column(0)
+        self._sid.get_child().set_width_chars(10)
+        self._sid.set_tooltip_text(xstr("takeoff_sid_tooltip"))
+        self._sid.connect("changed", self._upperChangedComboBox)
+
+        dataBox.pack_start(self._sid, False, False, 8)
+
+        return frame
+
+    def _buildArrivalFrame(self):
+        """Build the frame for the arrival data."""
+        (frame, mainBox) = PIREPViewer.createFrame(xstr("pirepView_frame_arrival"))
+
+        mainBox.pack_start(PIREPViewer.getLabel("METAR:"),
+                           False, False, 0)
+        (metarWindow, self._arrivalMETAR) = \
+            PIREPViewer.getTextWindow(heightRequest = -1,
+                                      editable = True)
+        mainBox.pack_start(metarWindow, True, True, 0)
+
+        PIREPViewer.addVFiller(mainBox)
+
+        table = gtk.Table(2, 4)
+        mainBox.pack_start(table, False, False, 0)
+        table.set_row_spacings(4)
+        table.set_col_spacings(8)
+
+        # FIXME: quite the same as in the wizard
+        if pygobject:
+            self._star = gtk.ComboBox.new_with_model_and_entry(comboModel)
+        else:
+            self._star = gtk.ComboBoxEntry(comboModel)
+
+        self._star.set_entry_text_column(0)
+        self._star.get_child().set_width_chars(10)
+        self._star.set_tooltip_text(xstr("landing_star_tooltip"))
+        self._star.connect("changed", self._upperChangedComboBox)
+
+        PIREPEditor.tableAttachWidget(table, 0, 0,
+                                      xstr("pirepView_star"),
+                                      self._star)
+
+        # FIXME: quite the same as in the wizard
+        if pygobject:
+            self._transition = gtk.ComboBox.new_with_model_and_entry(comboModel)
+        else:
+            self._transition = gtk.ComboBoxEntry(comboModel)
+
+        self._transition.set_entry_text_column(0)
+        self._transition.get_child().set_width_chars(10)
+        self._transition.set_tooltip_text(xstr("landing_transition_tooltip"))
+        self._transition.connect("changed", self._upperChangedComboBox)
+
+        PIREPEditor.tableAttachWidget(table, 2, 0,
+                                      xstr("pirepView_transition"),
+                                      self._transition)
+
+
+        # FIXME: quite the same as in the wizard
+        self._approachType = gtk.Entry()
+        self._approachType.set_width_chars(10)
+        self._approachType.set_tooltip_text(xstr("landing_approach_tooltip"))
+        self._approachType.connect("changed", self._upperChanged)
+
+        PIREPEditor.tableAttachWidget(table, 0, 1,
+                                      xstr("pirepView_approachType"),
+                                      self._approachType)
+
+        # FIXME: quite the same as in the wizard
+        self._arrivalRunway = gtk.Entry()
+        self._arrivalRunway.set_width_chars(10)
+        self._arrivalRunway.set_tooltip_text(xstr("landing_runway_tooltip"))
+        self._arrivalRunway.connect("changed", self._upperChanged)
+
+        PIREPEditor.tableAttachWidget(table, 2, 1,
+                                      xstr("pirepView_runway"),
+                                      self._arrivalRunway)
+
+        return frame
+
+    def _buildStatisticsFrame(self):
+        """Build the frame for the statistics data."""
+        (frame, mainBox) = PIREPViewer.createFrame(xstr("pirepView_frame_statistics"))
+
+        table = gtk.Table(4, 4)
+        mainBox.pack_start(table, False, False, 0)
+        table.set_row_spacings(4)
+        table.set_col_spacings(8)
+        table.set_homogeneous(False)
+
+        self._blockTimeStart = \
+            PIREPEditor.tableAttachTimeEntry(table, 0, 0,
+                                             xstr("pirepView_blockTimeStart"))
+
+        self._blockTimeEnd = \
+            PIREPEditor.tableAttachTimeEntry(table, 2, 0,
+                                             xstr("pirepView_blockTimeEnd"))
+
+        self._flightTimeStart = \
+            PIREPEditor.tableAttachTimeEntry(table, 0, 1,
+                                             xstr("pirepView_flightTimeStart"))
+
+        self._flightTimeEnd = \
+            PIREPEditor.tableAttachTimeEntry(table, 2, 1,
+                                             xstr("pirepView_flightTimeEnd"))
+
+        self._flownDistance = PIREPViewer.getDataLabel(width = 3)
+        PIREPEditor.tableAttachWidget(table, 0, 2,
+                                      xstr("pirepView_flownDistance"),
+                                      self._flownDistance)
+
+        self._fuelUsed = \
+            PIREPEditor.tableAttachSpinButton(table, 2, 2,
+                                              xstr("pirepView_fuelUsed"),
+                                              1000000)
+
+
+        self._rating = PIREPViewer.getDataLabel(width = 3)
+        PIREPEditor.tableAttachWidget(table, 0, 3,
+                                      xstr("pirepView_rating"),
+                                      self._rating)
+        return frame
+
+    def _buildMiscellaneousFrame(self):
+        """Build the frame for the miscellaneous data."""
+        (frame, mainBox) = PIREPViewer.createFrame(xstr("pirepView_frame_miscellaneous"))
+
+        table = gtk.Table(6, 2)
+        mainBox.pack_start(table, False, False, 0)
+        table.set_row_spacings(4)
+        table.set_col_spacings(8)
+        table.set_homogeneous(False)
+
+        self._flownNumPassengers = \
+            PIREPEditor.tableAttachSpinButton(table, 0, 0,
+                                              xstr("pirepView_numPassengers"),
+                                              300)
+
+        self._flownNumCrew = \
+            PIREPEditor.tableAttachSpinButton(table, 2, 0,
+                                              xstr("pirepView_numCrew"),
+                                              10)
+
+        self._flownBagWeight = \
+            PIREPEditor.tableAttachSpinButton(table, 0, 1,
+                                              xstr("pirepView_bagWeight"),
+                                              100000, width = 6)
+
+        self._flownCargoWeight = \
+            PIREPEditor.tableAttachSpinButton(table, 2, 1,
+                                              xstr("pirepView_cargoWeight"),
+                                              100000, width = 6)
+
+        self._flownMailWeight = \
+            PIREPEditor.tableAttachSpinButton(table, 4, 1,
+                                              xstr("pirepView_mailWeight"),
+                                              100000, width = 6)
+
+        self._flightType = createFlightTypeComboBox()
+        PIREPEditor.tableAttachWidget(table, 0, 2,
+                                      xstr("pirepView_flightType"),
+                                      self._flightType)
+
+        self._online = gtk.CheckButton(xstr("pirepView_online"))
+        table.attach(self._online, 2, 3, 2, 3)
+
+        PIREPViewer.addVFiller(mainBox)
+
+        mainBox.pack_start(PIREPViewer.getLabel(xstr("pirepView_delayCodes")),
+                           False, False, 0)
+
+        (textWindow, self._delayCodes) = PIREPViewer.getTextWindow()
+        mainBox.pack_start(textWindow, False, False, 0)
+
+        return frame
+
+    def _buildCommentsTab(self):
+        """Build the tab with the comments and flight defects."""
+        return FlightInfo(self._gui, mainInstance = False)
+
+    def _buildLogTab(self):
+        """Build the log tab."""
+        mainBox = gtk.VBox()
+
+        (logWindow, self._log) = PIREPViewer.getTextWindow(heightRequest = -1)
+        addFaultTag(self._log.get_buffer())
+        mainBox.pack_start(logWindow, True, True, 0)
+
+        return mainBox
+
+    def _upperChanged(self, entry, arg = None):
+        """Called when the value of some entry widget has changed and the value
+        should be converted to uppercase."""
+        entry.set_text(entry.get_text().upper())
+        #self._valueChanged(entry, arg)
+
+    def _upperChangedComboBox(self, comboBox):
+        """Called for combo box widgets that must be converted to uppercase."""
+        entry = comboBox.get_child()
+        if comboBox.get_active()==-1:
+            entry.set_text(entry.get_text().upper())
+        #self._valueChanged(entry)
+
+#------------------------------------------------------------------------------

src/mlx/pirep.py

@@ -202 +202 @@
         self.delayCodes = pirepData["timeComment"]
         if self.delayCodes=="UTC":
-            self.delayCodes = ""
+            self.delayCodes = []
+        else:
+            self.delayCodes = self.delayCodes.split(", ")
 
         flightDate = pirepData["flightDate"] + " "
@@ -371 +373 @@
         attrs["ratingText"] = self.getRatingText()
         attrs["rating"] = max(0.0, self.rating)
-        attrs["flownDistance"] = self.flownDistance
+        attrs["flownDistance"] = "%.2f" % (self.flownDistance,)
         # FIXME: it should be stored in the PIREP when it is sent later
         attrs["performDate"] = datetime.date.today().strftime("%Y-%m-%d")