Index: src/mlx/gui/acars.py
===================================================================
--- src/mlx/gui/acars.py	(revision 747)
+++ src/mlx/gui/acars.py	(revision 649)
@@ -13,5 +13,5 @@
 # The ACARS tab.
 #
-# This module implements to \ref ACARS class, which displays the MAVA ACARS in a
+# This module implements to \ref ACRS class, which displays the MAVA ACARS in a
 # browser window using CEF
 
@@ -21,5 +21,5 @@
     """The flight info tab."""
     # The URL of the ACARS map
-    URL = MAVA_BASE_URL + "/acars2/show.html"
+    URL = "http://virtualairlines.hu/acars2/show.html"
 
     def __init__(self, gui):
Index: src/mlx/gui/common.py
===================================================================
--- src/mlx/gui/common.py	(revision 741)
+++ src/mlx/gui/common.py	(revision 732)
@@ -279,119 +279,4 @@
                       else str(self._currentInteger))
         self._selfSetting = False
-
-#------------------------------------------------------------------------------
-
-class CredentialsDialog(gtk.Dialog):
-    """A dialog window to ask for a user name and a password."""
-    def __init__(self, gui, userName, password,
-                 titleLabel, cancelButtonLabel, okButtonLabel,
-                 userNameLabel, userNameTooltip,
-                 passwordLabel, passwordTooltip,
-                 infoText = None,
-                 rememberPassword = None,
-                 rememberLabel = None, rememberTooltip = None):
-        """Construct the dialog."""
-        super(CredentialsDialog, self).__init__(WINDOW_TITLE_BASE + " - " +
-                                                titleLabel,
-                                                gui.mainWindow,
-                                                DIALOG_MODAL)
-        self.add_button(cancelButtonLabel, RESPONSETYPE_CANCEL)
-        self.add_button(okButtonLabel, RESPONSETYPE_OK)
-
-        contentArea = self.get_content_area()
-
-        contentAlignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
-                                         xscale = 0.0, yscale = 0.0)
-        contentAlignment.set_padding(padding_top = 4, padding_bottom = 16,
-                                     padding_left = 8, padding_right = 8)
-
-        contentArea.pack_start(contentAlignment, False, False, 0)
-
-        contentVBox = gtk.VBox()
-        contentAlignment.add(contentVBox)
-
-        if infoText is not None:
-            label = gtk.Label(infoText)
-            label.set_alignment(0.0, 0.0)
-
-            contentVBox.pack_start(label, False, False, 0)
-
-        tableAlignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
-                                       xscale = 0.0, yscale = 0.0)
-        tableAlignment.set_padding(padding_top = 24, padding_bottom = 0,
-                                   padding_left = 0, padding_right = 0)
-
-        table = gtk.Table(3, 2)
-        table.set_row_spacings(4)
-        table.set_col_spacings(16)
-        table.set_homogeneous(False)
-
-        tableAlignment.add(table)
-        contentVBox.pack_start(tableAlignment, True, True, 0)
-
-        label = gtk.Label(userNameLabel)
-        label.set_use_underline(True)
-        label.set_alignment(0.0, 0.5)
-        table.attach(label, 0, 1, 0, 1)
-
-        self._userName = gtk.Entry()
-        self._userName.set_width_chars(16)
-        # FIXME: enabled the OK button only when there is something in thr
-        # user name and password fields
-        #self._userName.connect("changed",
-        #                       lambda button: self._updateForwardButton())
-        self._userName.set_tooltip_text(userNameTooltip)
-        self._userName.set_text(userName)
-        table.attach(self._userName, 1, 2, 0, 1)
-        label.set_mnemonic_widget(self._userName)
-
-        label = gtk.Label(passwordLabel)
-        label.set_use_underline(True)
-        label.set_alignment(0.0, 0.5)
-        table.attach(label, 0, 1, 1, 2)
-
-        self._password = gtk.Entry()
-        self._password.set_visibility(False)
-        #self._password.connect("changed",
-        #                       lambda button: self._updateForwardButton())
-        self._password.set_tooltip_text(passwordTooltip)
-        self._password.set_text(password)
-        table.attach(self._password, 1, 2, 1, 2)
-        label.set_mnemonic_widget(self._password)
-
-        if rememberPassword is not None:
-            self._rememberButton = gtk.CheckButton(rememberLabel)
-            self._rememberButton.set_use_underline(True)
-            self._rememberButton.set_tooltip_text(rememberTooltip)
-            self._rememberButton.set_active(rememberPassword)
-            table.attach(self._rememberButton, 1, 2, 2, 3, ypadding = 8)
-        else:
-            self._rememberButton = None
-
-    @property
-    def userName(self):
-        """Get the user name entered."""
-        return self._userName.get_text()
-
-    @property
-    def password(self):
-        """Get the password entered."""
-        return self._password.get_text()
-
-    @property
-    def rememberPassword(self):
-        """Get whether the password is to be remembered."""
-        return None if self._rememberButton is None \
-               else self._rememberButton.get_active()
-
-    def run(self):
-        """Run the dialog."""
-        self.show_all()
-
-        response = super(CredentialsDialog, self).run()
-
-        self.hide()
-
-        return response
 
 #------------------------------------------------------------------------------
Index: src/mlx/gui/flight.py
===================================================================
--- src/mlx/gui/flight.py	(revision 764)
+++ src/mlx/gui/flight.py	(revision 728)
@@ -11,5 +11,5 @@
 import mlx.util as util
 from mlx.pirep import PIREP
-from mlx.i18n import xstr, getLanguage
+from mlx.i18n import xstr
 from mlx.sound import startSound
 import mlx.web as web
@@ -20,6 +20,4 @@
 import tempfile
 import threading
-import re
-import webbrowser
 
 #-----------------------------------------------------------------------------
@@ -63,5 +61,5 @@
 class Page(gtk.Alignment):
     """A page in the flight wizard."""
-    def __init__(self, wizard, id, title, help, completedHelp = None):
+    def __init__(self, wizard, title, help, completedHelp = None):
         """Construct the page."""
         super(Page, self).__init__(xalign = 0.0, yalign = 0.0,
@@ -141,6 +139,4 @@
 
         self._wizard = wizard
-        self._id = id
-        self._nextPageID = None
 
         self._cancelFlightButton = None
@@ -148,19 +144,4 @@
         self._completed = False
         self._fromPage = None
-
-    @property
-    def id(self):
-        """Get the identifier of the page."""
-        return self._id
-
-    @property
-    def nextPageID(self):
-        """Get the identifier of the next page, if set."""
-        return self._nextPageID
-
-    @nextPageID.setter
-    def nextPageID(self, nextPageID):
-        """Set the identifier of the next page."""
-        self._nextPageID = nextPageID
 
     def setMainWidget(self, widget):
@@ -296,11 +277,11 @@
     def __init__(self, wizard):
         """Construct the login page."""
-        super(LoginPage, self).__init__(wizard, "login",
-                                        xstr("login"), xstr("loginHelp"))
+        super(LoginPage, self).__init__(wizard, xstr("login"),
+                                        xstr("loginHelp"))
 
         alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
                                   xscale = 0.0, yscale = 0.0)
 
-        table = gtk.Table(3, 2)
+        table = gtk.Table(4, 2)
         table.set_row_spacings(4)
         table.set_col_spacings(32)
@@ -340,7 +321,9 @@
         table.attach(self._rememberButton, 1, 2, 2, 3, ypadding = 8)
 
-        self.addButton(xstr("button_login_register"),
-                       clicked = self._registerClicked,
-                       tooltip = xstr("button_login_register_tooltip"))
+        self._entranceExam = gtk.CheckButton(xstr("login_entranceExam"))
+        self._entranceExam.set_use_underline(True)
+        self._entranceExam.set_tooltip_text(xstr("login_entranceExam_tooltip"))
+        self._entranceExam.connect("toggled", self._setControls)
+        table.attach(self._entranceExam, 1, 2, 3, 4, ypadding = 12)
 
         self.addButton(xstr("button_offline"),
@@ -352,4 +335,10 @@
         self._loginButton.set_tooltip_text(xstr("login_button_tooltip"))
 
+
+    @property
+    def entranceExam(self):
+        """Get whether an entrance exam is being performed."""
+        return self._entranceExam.get_active() and \
+               self._pilotID.get_text()!=""
 
     @property
@@ -390,10 +379,10 @@
         pilotID = self._pilotID.get_text()
         password = self._password.get_text()
-        self._rememberButton.set_sensitive(password!="")
-        self._loginButton.set_sensitive(pilotID!="" and password!="")
-
-    def _registerClicked(self, button):
-        """Called when the Register button was clicked."""
-        self._wizard.jumpPage("register")
+        entranceExam = self._entranceExam.get_active()
+        self._password.set_sensitive(not entranceExam)
+        self._rememberButton.set_sensitive(password!="" and not entranceExam)
+        self._entranceExam.set_sensitive(pilotID!="")
+        self._loginButton.set_sensitive(pilotID!="" and
+                                        (password!="" or entranceExam))
 
     def _offlineClicked(self, button):
@@ -407,5 +396,6 @@
         self._wizard.login(self._handleLoginResult,
                            self._pilotID.get_text(),
-                           self._password.get_text())
+                           self._password.get_text(),
+                           self.entranceExam)
 
     def _handleLoginResult(self, returned, result):
@@ -423,8 +413,5 @@
 
             config.save()
-            if result.rank=="STU":
-                self._wizard.jumpPage("student")
-            else:
-                self._wizard.nextPage()
+            self._wizard.nextPage()
 
 #-----------------------------------------------------------------------------
@@ -436,6 +423,5 @@
         help = xstr("flightsel_help")
         completedHelp = xstr("flightsel_chelp")
-        super(FlightSelectionPage, self).__init__(wizard, "flightsel",
-                                                  xstr("flightsel_title"),
+        super(FlightSelectionPage, self).__init__(wizard, xstr("flightsel_title"),
                                                   help, completedHelp = completedHelp)
 
@@ -617,5 +603,5 @@
         """Called when the forward button was clicked."""
         if self._completed:
-            self._wizard.jumpPage(self._nextID, finalize = False)
+            self._wizard.jumpPage(self._nextDistance, finalize = False)
         else:
             self._flightSelected()
@@ -672,30 +658,30 @@
                                          const.PLANE_AWAY)
         else:
-            self._nextID = "connect"
-            self._wizard.jumpPage("connect")
+            self._nextDistance = 2
+            self._wizard.jumpPage(2)
 
     def _fleetRetrieved(self, fleet):
         """Called when the fleet has been retrieved."""
         if fleet is None:
-            self._nextID = "connect"
-            self._wizard.jumpPage("connect")
+            self._nextDistance = 2
+            self._wizard.jumpPage(2)
         else:
             plane = fleet[self._wizard._bookedFlight.tailNumber]
             if plane is None:
-                self._nextID = "connect"
-                self._wizard.jumpPage("connect")
+                self._nextDistance = 2
+                self._wizard.jumpPage(2)
             elif plane.gateNumber is not None and \
                  not fleet.isGateConflicting(plane):
                 self._wizard._departureGate = plane.gateNumber
-                self._nextID = "connect"
-                self._wizard.jumpPage("connect")
+                self._nextDistance = 2
+                self._wizard.jumpPage(2)
             else:
-                self._nextID = "gatesel"
-                self._wizard.jumpPage("gatesel")
+                self._nextDistance = 1
+                self._wizard.nextPage()
 
     def _planeUpdated(self, success):
         """Callback for the plane updating."""
-        self._nextID = "connect"
-        self._wizard.jumpPage("connect")
+        self._nextDistance = 2
+        self._wizard.jumpPage(2)
 
     def _getSaveDialog(self):
@@ -800,6 +786,5 @@
     def __init__(self, wizard):
         """Construct the gate selection page."""
-        super(GateSelectionPage, self).__init__(wizard, "gatesel",
-                                                xstr("gatesel_title"),
+        super(GateSelectionPage, self).__init__(wizard, xstr("gatesel_title"),
                                                 xstr("gatesel_help"))
 
@@ -864,5 +849,5 @@
             self._gateSelected()
         else:
-            self._wizard.jumpPage("connect")
+            self._wizard.nextPage()
 
     def _rowActivated(self, flightList, path, column):
@@ -886,5 +871,5 @@
         """Callback for the plane updating call."""
         if success is None or success:
-            self._wizard.jumpPage("connect")
+            self._wizard.nextPage()
         else:
             dialog = gtk.MessageDialog(parent = self._wizard.gui.mainWindow,
@@ -902,554 +887,7 @@
         """Called when the fleet has been retrieved."""
         if fleet is None:
-            self._wizard.jumpPage("connect")
+            self._wizard.nextPage()
         else:
             self.activate()
-
-#-----------------------------------------------------------------------------
-
-class RegisterPage(Page):
-    """A page to enter the registration data."""
-
-    # The minimal year of birth
-    _minYearOfBirth = 1900
-
-    # The maximal year of birth
-    _maxYearOfBirth = datetime.date.today().year
-
-    # The regular expression to check the e-mail address with
-    _emailAddressRE = re.compile("[^@]+@[^@]+\.[^@]+")
-
-    def __init__(self, wizard):
-        """Construct the registration page."""
-        super(RegisterPage, self).__init__(wizard, "register",
-                                           xstr("register_title"),
-                                           xstr("register_help"))
-
-        alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
-                                  xscale = 0.0, yscale = 0.0)
-
-        table = gtk.Table(12, 3)
-        table.set_row_spacings(4)
-        table.set_col_spacings(32)
-        alignment.add(table)
-        self.setMainWidget(alignment)
-
-        row = 0
-
-        labelAlignment = gtk.Alignment(xalign = 1.0, yalign = 0.5,
-                                       xscale = 0.0, yscale = 0.0)
-        label = gtk.Label(xstr("register_name1"))
-        label.set_use_underline(True)
-        labelAlignment.add(label)
-        table.attach(labelAlignment, 0, 1, row, row+1)
-
-        self._name1 = gtk.Entry()
-        self._name1.connect("changed", self._updateButtons)
-        self._name1.set_tooltip_text(xstr("register_name1_tooltip"))
-        self._name1.set_width_chars(15)
-        table.attach(self._name1, 1, 2, row, row+1)
-        label.set_mnemonic_widget(self._name1)
-
-        row += 1
-
-        labelAlignment = gtk.Alignment(xalign = 1.0, yalign = 0.5,
-                                       xscale = 0.0, yscale = 0.0)
-        label = gtk.Label(xstr("register_name2"))
-        label.set_use_underline(True)
-        labelAlignment.add(label)
-        table.attach(labelAlignment, 0, 1, row, row+1)
-
-        self._name2 = gtk.Entry()
-        self._name2.connect("changed", self._updateButtons)
-        self._name2.set_tooltip_text(xstr("register_name2_tooltip"))
-        self._name2.set_width_chars(15)
-        table.attach(self._name2, 1, 2, row, row+1)
-        label.set_mnemonic_widget(self._name2)
-
-        row += 1
-
-        labelAlignment = gtk.Alignment(xalign = 1.0, yalign = 0.5,
-                                       xscale = 0.0, yscale = 0.0)
-        label = gtk.Label(xstr("register_year_of_birth"))
-        label.set_use_underline(True)
-        labelAlignment.add(label)
-        table.attach(labelAlignment, 0, 1, row, row+1)
-
-        alignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
-                                  xscale = 0.0, yscale = 0.0)
-
-        self._yearOfBirth = gtk.SpinButton()
-        self._yearOfBirth.set_increments(step = 1, page = 10)
-        self._yearOfBirth.set_range(min = RegisterPage._minYearOfBirth,
-                                    max = RegisterPage._maxYearOfBirth)
-        self._yearOfBirth.set_numeric(True)
-        self._yearOfBirth.set_tooltip_text(xstr("register_year_of_birth_tooltip"))
-        self._yearOfBirth.set_width_chars(5)
-        self._yearOfBirth.connect("changed", self._updateButtons)
-        self._yearOfBirth.connect("value-changed", self._updateButtons)
-        alignment.add(self._yearOfBirth)
-        table.attach(alignment, 1, 2, row, row+1)
-        label.set_mnemonic_widget(self._yearOfBirth)
-
-        row += 1
-
-        labelAlignment = gtk.Alignment(xalign = 1.0, yalign = 0.5,
-                                       xscale = 0.0, yscale = 0.0)
-        label = gtk.Label(xstr("register_email"))
-        label.set_use_underline(True)
-        labelAlignment.add(label)
-        table.attach(labelAlignment, 0, 1, row, row+1)
-
-        self._emailAddress = gtk.Entry()
-        self._emailAddress.connect("changed", self._updateButtons)
-        self._emailAddress.set_tooltip_text(xstr("register_email_tooltip"))
-        table.attach(self._emailAddress, 1, 2, row, row+1)
-        label.set_mnemonic_widget(self._emailAddress)
-
-        self._emailAddressPublic = gtk.CheckButton(xstr("register_email_public"))
-        self._emailAddressPublic.set_use_underline(True)
-        self._emailAddressPublic.set_tooltip_text(xstr("register_email_public_tooltip"))
-        table.attach(self._emailAddressPublic, 2, 3, row, row+1)
-
-        row += 1
-
-        labelAlignment = gtk.Alignment(xalign = 1.0, yalign = 0.5,
-                                       xscale = 0.0, yscale = 0.0)
-        label = gtk.Label(xstr("register_vatsim_id"))
-        label.set_use_underline(True)
-        labelAlignment.add(label)
-        table.attach(labelAlignment, 0, 1, row, row+1)
-
-        alignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
-                                  xscale = 0.0, yscale = 0.0)
-        self._vatsimID = IntegerEntry()
-        self._vatsimID.connect("changed", self._updateButtons)
-        self._vatsimID.set_tooltip_text(xstr("register_vatsim_id_tooltip"))
-        self._vatsimID.set_width_chars(7)
-        alignment.add(self._vatsimID)
-        table.attach(alignment, 1, 2, row, row+1)
-        label.set_mnemonic_widget(self._vatsimID)
-
-        row += 1
-
-        labelAlignment = gtk.Alignment(xalign = 1.0, yalign = 0.5,
-                                       xscale = 0.0, yscale = 0.0)
-        label = gtk.Label(xstr("register_ivao_id"))
-        label.set_use_underline(True)
-        labelAlignment.add(label)
-        table.attach(labelAlignment, 0, 1, row, row+1)
-
-        alignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
-                                  xscale = 0.0, yscale = 0.0)
-        self._ivaoID = IntegerEntry()
-        self._ivaoID.connect("changed", self._updateButtons)
-        self._ivaoID.set_tooltip_text(xstr("register_ivao_id_tooltip"))
-        self._ivaoID.set_width_chars(7)
-        alignment.add(self._ivaoID)
-        table.attach(alignment, 1, 2, row, row+1)
-        label.set_mnemonic_widget(self._ivaoID)
-
-        row += 1
-
-        labelAlignment = gtk.Alignment(xalign = 1.0, yalign = 0.5,
-                                       xscale = 0.0, yscale = 0.0)
-        label = gtk.Label(xstr("register_phone_num"))
-        label.set_use_underline(True)
-        label.set_use_markup(True)
-        labelAlignment.add(label)
-        table.attach(labelAlignment, 0, 1, row, row+1)
-
-        self._phoneNumber = gtk.Entry()
-        self._phoneNumber.set_tooltip_text(xstr("register_phone_num_tooltip"))
-        table.attach(self._phoneNumber, 1, 2, row, row+1)
-        label.set_mnemonic_widget(self._phoneNumber)
-
-        row += 1
-
-        labelAlignment = gtk.Alignment(xalign = 1.0, yalign = 0.5,
-                                       xscale = 0.0, yscale = 0.0)
-        label = gtk.Label(xstr("register_nationality"))
-        label.set_use_underline(True)
-        label.set_use_markup(True)
-        labelAlignment.add(label)
-        table.attach(labelAlignment, 0, 1, row, row+1)
-
-
-        self._nationality = gtk.Entry()
-        self._nationality.set_tooltip_text(xstr("register_nationality_tooltip"))
-        table.attach(self._nationality, 1, 2, row, row+1)
-        label.set_mnemonic_widget(self._nationality)
-
-        placeholder = gtk.Label()
-        placeholder.set_text(xstr("register_password_mismatch"))
-        placeholder.set_use_markup(True)
-        placeholder.set_child_visible(False)
-        placeholder.hide()
-        table.attach(placeholder, 2, 3, row, row+1)
-
-        row += 1
-
-        labelAlignment = gtk.Alignment(xalign = 1.0, yalign = 0.5,
-                                       xscale = 0.0, yscale = 0.0)
-        label = gtk.Label(xstr("register_password"))
-        label.set_use_underline(True)
-        labelAlignment.add(label)
-        table.attach(labelAlignment, 0, 1, row, row+1)
-
-        self._password = gtk.Entry()
-        self._password.set_visibility(False)
-        self._password.connect("changed", self._updateButtons)
-        self._password.set_tooltip_text(xstr("register_password_tooltip"))
-        table.attach(self._password, 1, 2, row, row+1)
-        label.set_mnemonic_widget(self._password)
-
-        alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
-                                  xscale = 0.0, yscale = 0.0)
-        self._passwordStatus = gtk.Label()
-        alignment.add(self._passwordStatus)
-        table.attach(alignment, 2, 3, row, row+1)
-
-        row += 1
-
-        labelAlignment = gtk.Alignment(xalign = 1.0, yalign = 0.5,
-                                       xscale = 0.0, yscale = 0.0)
-        label = gtk.Label(xstr("register_password2"))
-        label.set_use_underline(True)
-        labelAlignment.add(label)
-        table.attach(labelAlignment, 0, 1, row, row+1)
-
-        self._password2 = gtk.Entry()
-        self._password2.set_visibility(False)
-        self._password2.connect("changed", self._updateButtons)
-        self._password2.set_tooltip_text(xstr("register_password2_tooltip"))
-        table.attach(self._password2, 1, 2, row, row+1)
-        label.set_mnemonic_widget(self._password2)
-
-        alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
-                                  xscale = 0.0, yscale = 0.0)
-        self._password2Status = gtk.Label()
-        alignment.add(self._password2Status)
-        table.attach(alignment, 2, 3, row, row+1)
-
-        row += 1
-
-        self._rememberButton = gtk.CheckButton(xstr("remember_password"))
-        self._rememberButton.set_use_underline(True)
-        self._rememberButton.set_tooltip_text(xstr("login_remember_tooltip"))
-        table.attach(self._rememberButton, 1, 2, row, row+1)
-
-        cancelButton = \
-          self.addButton(xstr("button_cancel"))
-        cancelButton.connect("clicked", self._cancelClicked)
-
-        self._registerButton = \
-          self.addButton(xstr("button_register"), default = True,
-                              tooltip = xstr("button_register_tooltip"))
-        self._registerButton.connect("clicked", self._registerClicked)
-
-        self._updateButtons()
-
-    @property
-    def name1(self):
-        """Get the first name component entered."""
-        return self._name1.get_text()
-
-    @property
-    def name2(self):
-        """Get the second name component entered."""
-        return self._name2.get_text()
-
-    @property
-    def yearOfBirth(self):
-        """Get the year of birth."""
-        yearOfBirthText = self._yearOfBirth.get_text()
-        return int(yearOfBirthText) if yearOfBirthText else 0
-
-    @property
-    def emailAddress(self):
-        """Get the e-mail address."""
-        return self._emailAddress.get_text()
-
-    @property
-    def emailAddressPublic(self):
-        """Get the whether the e-mail address is public."""
-        return self._emailAddressPublic.get_active()
-
-    @property
-    def vatsimID(self):
-        """Get the VATSIM ID."""
-        return self._vatsimID.get_int()
-
-    @property
-    def ivaoID(self):
-        """Get the IVAO ID."""
-        return self._ivaoID.get_int()
-
-    @property
-    def phoneNumber(self):
-        """Get the phone number."""
-        return self._phoneNumber.get_text()
-
-    @property
-    def nationality(self):
-        """Get the nationality."""
-        return self._nationality.get_text()
-
-    @property
-    def password(self):
-        """Get the password."""
-        return self._password.get_text()
-
-    @property
-    def rememberPassword(self):
-        """Get whether the password should be remembered."""
-        return self._rememberButton.get_active()
-
-    def activate(self):
-        """Setup the route from the booked flight."""
-        self._yearOfBirth.set_value(0)
-        self._yearOfBirth.set_text("")
-        self._updateButtons()
-
-    def _updateButtons(self, widget = None):
-        """Update the sensitive state of the buttons"""
-        yearOfBirth = self.yearOfBirth
-
-        emailAddress = self.emailAddress
-        emailAddressMatch = RegisterPage._emailAddressRE.match(emailAddress)
-
-        vatsimID = self.vatsimID
-        ivaoID = self.ivaoID
-
-        password = self.password
-        password2 = self._password2.get_text()
-        if not password:
-            self._passwordStatus.set_text("")
-        elif len(password)<5:
-            self._passwordStatus.set_text(xstr("register_password_too_short"))
-        else:
-            self._passwordStatus.set_text(xstr("register_password_ok"))
-        self._passwordStatus.set_use_markup(True)
-
-        if len(password)<5 or not password2:
-            self._password2Status.set_text("")
-        elif password!=password2:
-            self._password2Status.set_text(xstr("register_password_mismatch"))
-        else:
-            self._password2Status.set_text(xstr("register_password_ok"))
-        self._password2Status.set_use_markup(True)
-
-        sensitive = \
-            len(self.name1)>0 and len(self.name2)>0 and \
-            yearOfBirth>=RegisterPage._minYearOfBirth and \
-            yearOfBirth<=RegisterPage._maxYearOfBirth and \
-            emailAddressMatch is not None and \
-            (vatsimID>=800000 or ivaoID>=100000) and \
-            len(password)>=5 and password==password2
-
-        self._registerButton.set_sensitive(sensitive)
-
-    def _cancelClicked(self, button):
-        """Called when the Cancel button is clicked."""
-        self.goBack()
-
-    def _registerClicked(self, button):
-        """Called when the Register button is clicked."""
-        nameOrder = xstr("register_nameorder")
-
-        if nameOrder=="eastern":
-            surName = self.name1
-            firstName = self.name2
-        else:
-            surName = self.name2
-            firstName = self.name1
-
-        nationality = self.nationality.lower()
-
-        if getLanguage().lower()=="hu" or nationality.find("hung")!=-1 or \
-           nationality.find("magyar")!=-1:
-            requestedNameOrder = "eastern"
-        else:
-            requestedNameOrder = "western"
-
-        registrationData = web.Registration(surName, firstName,
-                                            requestedNameOrder,
-                                            self.yearOfBirth,
-                                            self.emailAddress,
-                                            self.emailAddressPublic,
-                                            self.vatsimID, self.ivaoID,
-                                            self.phoneNumber, self.nationality,
-                                            self.password)
-        print "Registering with data:"
-        print "  name:", self.name1, self.name2, registrationData.firstName, registrationData.surName, requestedNameOrder
-        print "  yearOfBirth:", self.yearOfBirth, registrationData.yearOfBirth
-        print "  emailAddress:", self.emailAddress, registrationData.emailAddress
-        print "  emailAddressPublic:", self.emailAddressPublic, registrationData.emailAddressPublic
-        print "  vatsimID:", self.vatsimID, registrationData.vatsimID
-        print "  ivaoID:", self.ivaoID, registrationData.ivaoID
-        print "  phoneNumber:", self.phoneNumber, registrationData.phoneNumber
-        print "  nationality:", self.nationality, registrationData.nationality
-
-        gui = self._wizard.gui
-        gui.beginBusy(xstr("register_busy"))
-        gui.webHandler.register(self._registerResultCallback, registrationData)
-
-    def _registerResultCallback(self, returned, result):
-        """Called when the registration result is available."""
-        gobject.idle_add(self._handleRegisterResult, returned, result)
-
-    def _handleRegisterResult(self, returned, result):
-        """Handle the registration result."""
-        gui = self._wizard.gui
-
-        gui.endBusy()
-
-        print "Registration result:"
-        print "  returned:", returned
-        if returned:
-            print "  registered:", result.registered
-            if result.registered:
-                print "  pilotID", result.pilotID
-                print "  loggedIn", result.loggedIn
-            print "  emailAlreadyRegistered:", result.emailAlreadyRegistered
-            print "  invalidData:", result.invalidData
-
-        registrationOK = returned and result.registered
-
-        message = xstr("register_ok") if registrationOK \
-                  else xstr("register_failed")
-        secondaryMessage = None
-        if registrationOK:
-            if result.loggedIn:
-                secondaryMessage = xstr("register_info") % (result.pilotID,)
-            else:
-                secondaryMessage = xstr("register_nologin") % (result.pilotID,)
-            messageType = MESSAGETYPE_INFO
-
-            config = gui.config
-            config.pilotID = result.pilotID
-            config.rememberPassword = self.rememberPassword
-            if config.rememberPassword:
-                config.password = self.password
-            else:
-                config.password = ""
-
-            config.save()
-        elif returned and result.emailAlreadyRegistered:
-            secondaryMessage = xstr("register_email_already")
-            messageType = MESSAGETYPE_ERROR
-        elif returned and result.invalidData:
-            secondaryMessage = xstr("register_invalid_data")
-            messageType = MESSAGETYPE_ERROR
-        else:
-            secondaryMessage = xstr("register_error")
-            messageType = MESSAGETYPE_ERROR
-
-        dialog = gtk.MessageDialog(parent = gui.mainWindow,
-                                   type = messageType,
-                                   message_format = message)
-        dialog.set_title(WINDOW_TITLE_BASE + " - " +
-                         xstr("register_result_title"))
-        dialog.format_secondary_markup(secondaryMessage)
-
-        dialog.add_button(xstr("button_ok"), 0)
-
-        dialog.run()
-        dialog.hide()
-
-        if registrationOK:
-            if result.loggedIn:
-                self._wizard.nextPage()
-            else:
-                self._wizard.jumpPage("login")
-
-#-----------------------------------------------------------------------------
-
-class StudentPage(Page):
-    """A page displayed to students after logging in."""
-    _entryExamStatusQueryInterval = 60*1000
-
-    def __init__(self, wizard):
-        """Construct the student page."""
-        super(StudentPage, self).__init__(wizard, "student",
-                                          xstr("student_title"),
-                                          xstr("student_help"))
-
-        alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
-                                  xscale = 0.5, yscale = 0.0)
-
-        table = gtk.Table(2, 2)
-        table.set_row_spacings(4)
-        table.set_col_spacings(32)
-        table.set_homogeneous(False)
-        alignment.add(table)
-        self.setMainWidget(alignment)
-
-        row = 0
-
-        labelAlignment = gtk.Alignment(xalign=0.0, yalign = 0.5,
-                                       xscale=0.0, yscale = 0.0)
-        label = gtk.Label(xstr("student_entry_exam_status"))
-        labelAlignment.add(label)
-        table.attach(labelAlignment, 0, 1, row, row + 1, xoptions = 0)
-
-        alignment = gtk.Alignment(xalign=0.0, yalign = 0.5,
-                                  xscale=1.0, yscale = 0.0)
-        self._entryExamStatus = gtk.Label()
-        self._entryExamStatus.set_use_markup(True)
-        self._entryExamStatus.set_alignment(0.0, 0.5)
-        alignment.add(self._entryExamStatus)
-        table.attach(alignment, 1, 2, row, row + 1)
-
-        row += 1
-
-        buttonAlignment = gtk.Alignment(xalign=0.0, xscale=1.0)
-        button = self._entryExamButton = gtk.Button(xstr("student_entry_exam"))
-        button.set_use_underline(True)
-        button.connect("clicked", self._entryExamClicked)
-        button.set_tooltip_text(xstr("student_entry_exam_tooltip"))
-
-        buttonAlignment.add(button)
-        table.attach(buttonAlignment, 0, 2, row, row + 1,
-                     ypadding = 4)
-
-    def activate(self):
-        """Activate the student page."""
-        loginResult = self._wizard.loginResult
-        self._entryExamLink = loginResult.entryExamLink
-
-        self._updateEntryExamStatus(loginResult.entryExamPassed)
-
-        self._getEntryExamStatus()
-
-    def _entryExamClicked(self, button):
-        """Called when the entry exam button is clicked."""
-        webbrowser.open(self._entryExamLink)
-
-    def _getEntryExamStatus(self):
-        """Initiate the query of the entry exam status after the interval."""
-        gobject.timeout_add(StudentPage._entryExamStatusQueryInterval,
-                            lambda: self._wizard.gui.webHandler. \
-                            getEntryExamStatus(self._entryExamStatusCallback))
-
-    def _entryExamStatusCallback(self, returned, result):
-        """Called when the entry exam status is available."""
-        gobject.idle_add(self._handleEntryExamStatus, returned, result)
-
-    def _handleEntryExamStatus(self, returned, result):
-        """Called when the entry exam status is availabe."""
-        print "_handleEntryExamStatus", returned, result
-        if returned:
-            self._entryExamLink = result.entryExamLink
-            self._updateEntryExamStatus(result.entryExamPassed)
-            self._getEntryExamStatus()
-
-    def _updateEntryExamStatus(self, passed):
-        """Update the entry exam status display and button."""
-        self._entryExamStatus.set_text(xstr("student_entry_exam_passed")
-                                       if passed else
-                                       xstr("student_entry_exam_not_passed"))
-        self._entryExamStatus.set_use_markup(True)
-        self._entryExamButton.set_sensitive(not passed)
 
 #-----------------------------------------------------------------------------
@@ -1463,6 +901,5 @@
                "Then press the Connect button to connect to the simulator."
         completedHelp = "The basic data of your flight can be read below."
-        super(ConnectPage, self).__init__(wizard, "connect",
-                                          xstr("connect_title"),
+        super(ConnectPage, self).__init__(wizard, xstr("connect_title"),
                                           xstr("connect_help"),
                                           completedHelp = xstr("connect_chelp"))
@@ -1647,6 +1084,5 @@
     def __init__(self, wizard):
         """Construct the page."""
-        super(PayloadPage, self).__init__(wizard, "payload",
-                                          xstr("payload_title"),
+        super(PayloadPage, self).__init__(wizard, xstr("payload_title"),
                                           xstr("payload_help"),
                                           completedHelp = xstr("payload_chelp"))
@@ -1875,6 +1311,5 @@
     current time from the flight simulator."""
     def __init__(self, wizard):
-        super(TimePage, self).__init__(wizard, "time",
-                                       xstr("time_title"),
+        super(TimePage, self).__init__(wizard, xstr("time_title"),
                                        xstr("time_help"),
                                        completedHelp = xstr("time_chelp"))
@@ -1997,6 +1432,5 @@
     def __init__(self, wizard):
         """Construct the page."""
-        super(RoutePage, self).__init__(wizard, "route",
-                                        xstr("route_title"),
+        super(RoutePage, self).__init__(wizard, xstr("route_title"),
                                         xstr("route_help"),
                                         completedHelp = xstr("route_chelp"))
@@ -2166,8 +1600,8 @@
         if self._wizard.gui.config.useSimBrief and \
            self._wizard.usingSimBrief is not False:
-            self._wizard.jumpPage("simbrief_setup")
+            self._wizard.nextPage()
         else:
             self._wizard.usingSimBrief = False
-            self._wizard.jumpPage("fuel")
+            self._wizard.jumpPage(3)
 
 #-----------------------------------------------------------------------------
@@ -2328,5 +1762,5 @@
         """Construct the setup page."""
 
-        super(SimBriefSetupPage, self).__init__(wizard, "simbrief_setup",
+        super(SimBriefSetupPage, self).__init__(wizard,
                                                 xstr("simbrief_setup_title"),
                                                 xstr("simbrief_setup_help"),
@@ -2647,5 +2081,5 @@
 
                 self._wizard.usingSimBrief = False
-                self._wizard.jumpPage("fuel", fromPageShift = 1)
+                self._wizard.jumpPage(2, fromPageShift = 1)
 
     def _getPlan(self):
@@ -2732,5 +2166,5 @@
         """Construct the setup page."""
 
-        super(SimBriefingPage, self).__init__(wizard, "simbrief_result",
+        super(SimBriefingPage, self).__init__(wizard,
                                               xstr("simbrief_result_title"), "")
 
@@ -2988,6 +2422,5 @@
     def __init__(self, wizard):
         """Construct the page."""
-        super(FuelPage, self).__init__(wizard, "fuel",
-                                       xstr("fuel_title"),
+        super(FuelPage, self).__init__(wizard, xstr("fuel_title"),
                                        xstr("fuel_help_pre") +
                                        xstr("fuel_help_post"),
@@ -3041,7 +2474,7 @@
             self._pump()
         elif self._wizard.usingSimBrief:
-            self._wizard.jumpPage("takeoff")
+            self._wizard.jumpPage(3)
         else:
-            self._wizard.jumpPage("briefing1")
+            self._wizard.nextPage()
 
     def _setupTanks(self, tankData):
@@ -3089,5 +2522,5 @@
             if self._wizard.usingSimBrief:
                 self._wizard.gui.startMonitoring()
-                self._wizard.jumpPage("takeoff")
+                self._wizard.jumpPage(3)
             else:
                 bookedFlight = self._wizard._bookedFlight
@@ -3158,13 +2591,9 @@
         self._departure = departure
 
-        number = 1 if departure else 2
-
-        title = xstr("briefing_title") % (number,
+        title = xstr("briefing_title") % (1 if departure else 2,
                                           xstr("briefing_departure")
                                           if departure
                                           else xstr("briefing_arrival"))
-        super(BriefingPage, self).__init__(wizard,
-                                           "briefing%d" % (number,),
-                                           title, xstr("briefing_help"),
+        super(BriefingPage, self).__init__(wizard, title, xstr("briefing_help"),
                                            completedHelp = xstr("briefing_chelp"))
 
@@ -3353,6 +2782,5 @@
     def __init__(self, wizard):
         """Construct the takeoff page."""
-        super(TakeoffPage, self).__init__(wizard, "takeoff",
-                                          xstr("takeoff_title"),
+        super(TakeoffPage, self).__init__(wizard, xstr("takeoff_title"),
                                           xstr("takeoff_help"),
                                           completedHelp = xstr("takeoff_chelp"))
@@ -3842,6 +3270,5 @@
     def __init__(self, wizard):
         """Construct the page."""
-        super(CruisePage, self).__init__(wizard, "cruise",
-                                         xstr("cruise_title"),
+        super(CruisePage, self).__init__(wizard, xstr("cruise_title"),
                                          xstr("cruise_help"))
 
@@ -3957,6 +3384,5 @@
     def __init__(self, wizard):
         """Construct the landing page."""
-        super(LandingPage, self).__init__(wizard, "landing",
-                                          xstr("landing_title"),
+        super(LandingPage, self).__init__(wizard, xstr("landing_title"),
                                           xstr("landing_help"),
                                           completedHelp = xstr("landing_chelp"))
@@ -4272,6 +3698,5 @@
         """Construct the finish page."""
         help = xstr("finish_help") + xstr("finish_help_goodtime")
-        super(FinishPage, self).__init__(wizard, "finish",
-                                         xstr("finish_title"), help)
+        super(FinishPage, self).__init__(wizard, xstr("finish_title"), help)
 
         alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
@@ -4831,6 +4256,4 @@
         self._pages.append(FlightSelectionPage(self))
         self._pages.append(GateSelectionPage(self))
-        self._pages.append(RegisterPage(self))
-        self._pages.append(StudentPage(self))
         self._pages.append(ConnectPage(self))
         self._payloadPage = PayloadPage(self)
@@ -4905,5 +4328,5 @@
     def entranceExam(self):
         """Get whether an entrance exam is about to be taken."""
-        return self._loginResult is not None and self._loginResult.rank=="STU"
+        return self._loginPage.entranceExam
 
     @property
@@ -5128,14 +4551,9 @@
     def nextPage(self, finalize = True):
         """Go to the next page."""
-        nextPageID = self._pages[self._currentPage].nextPageID
-        self.jumpPage(1 if nextPageID is None else nextPageID, finalize)
-
-    def jumpPage(self, countOrID, finalize = True, fromPageShift = None):
+        self.jumpPage(1, finalize)
+
+    def jumpPage(self, count, finalize = True, fromPageShift = None):
         """Go to the page which is 'count' pages after the current one."""
-        if isinstance(countOrID, str):
-            targetIndex = self._getIndexOf(countOrID)
-        else:
-            targetIndex = self._currentPage + countOrID
-        self.setCurrentPage(targetIndex,
+        self.setCurrentPage(self._currentPage + count,
                             finalize = finalize, fromPageShift = fromPageShift)
 
@@ -5198,5 +4616,5 @@
         #self.setCurrentPage(10)
 
-    def login(self, callback, pilotID, password):
+    def login(self, callback, pilotID, password, entranceExam):
         """Called when the login button was clicked."""
         self._loginCallback = callback
@@ -5206,4 +4624,5 @@
             pilotID = loginResult.pilotID
             password = loginResult.password
+            entranceExam = loginResult.entranceExam
             busyMessage = xstr("reload_busy")
         else:
@@ -5214,5 +4633,6 @@
 
         self.gui.webHandler.login(self._loginResultCallback,
-                                  pilotID, password)
+                                  pilotID, password,
+                                  entranceExam = entranceExam)
 
     def reloadFlights(self, callback):
@@ -5262,4 +4682,5 @@
         """Handle the login result."""
         self.gui.endBusy()
+        returned = True
         isReload = self._loginResult is not None
         if returned:
@@ -5367,13 +4788,3 @@
                 self._arrivalBriefingPage.setMETAR(metar)
 
-    def _getIndexOf(self, pageID):
-        """Get the index for the given page ID.
-
-        It is an assertion failure if the ID is not found."""
-        for index in range(0, len(self._pages)):
-            page = self._pages[index]
-            if page.id==pageID:
-                return index
-        assert False
-
 #-----------------------------------------------------------------------------
Index: src/mlx/gui/gui.py
===================================================================
--- src/mlx/gui/gui.py	(revision 755)
+++ src/mlx/gui/gui.py	(revision 733)
@@ -90,10 +90,5 @@
         self._sendBugReportCallback = None
 
-        self._credentialsCondition = threading.Condition()
-        self._credentialsAvailable = False
-        self._credentialsUserName = None
-        self._credentialsPassword = None
-
-        self.webHandler = web.Handler(config, self._getCredentialsCallback)
+        self.webHandler = web.Handler()
         self.webHandler.start()
 
@@ -447,6 +442,4 @@
                                     self._mainWindow)
             self._updater.start()
-        else:
-            self.updateDone()
 
         cef.initialize(self._programDirectory, self._cefInitialized)
@@ -459,8 +452,4 @@
 
         self._disconnect()
-
-    def updateDone(self):
-        """Called when the update is done (and there is no need to restart)."""
-        gobject.idle_add(self._updateDone)
 
     def connected(self, fsType, descriptor):
@@ -1646,78 +1635,2 @@
         """Set the anti-ice on indicator."""
         self._wizard.landingAntiIceOn = value
-
-    def _getCredentialsCallback(self):
-        """Called when the web handler asks for the credentials."""
-        # FIXME: this is almost the same as
-        # SimBriefSetupPage._getCredentialsCallback
-        with self._credentialsCondition:
-            self._credentialsAvailable = False
-
-            gobject.idle_add(self._getCredentials)
-
-            while not self._credentialsAvailable:
-                self._credentialsCondition.wait()
-
-            return (self._credentialsUserName, self._credentialsPassword)
-
-    def _getCredentials(self):
-        """Get the credentials."""
-        # FIXME: this is almost the same as
-        # SimBriefSetupPage._getCredentials
-        with self._credentialsCondition:
-            config = self.config
-
-            dialog = CredentialsDialog(self, config.pilotID, config.password,
-                                       xstr("login_title"),
-                                       xstr("button_cancel"),
-                                       xstr("button_ok"),
-                                       xstr("label_pilotID"),
-                                       xstr("login_pilotID_tooltip"),
-                                       xstr("label_password"),
-                                       xstr("login_password_tooltip"),
-                                       xstr("login_info"),
-                                       config.rememberPassword,
-                                       xstr("remember_password"),
-                                       xstr("login_remember_tooltip"))
-            response = dialog.run()
-
-            if response==RESPONSETYPE_OK:
-                self._credentialsUserName = dialog.userName
-                self._credentialsPassword = dialog.password
-                rememberPassword = dialog.rememberPassword
-
-                config.pilotID = self._credentialsUserName
-
-                config.password = \
-                  self._credentialsPassword if rememberPassword else ""
-                config.rememberPassword = rememberPassword
-
-                config.save()
-            else:
-                self._credentialsUserName = None
-                self._credentialsPassword = None
-
-            self._credentialsAvailable = True
-            self._credentialsCondition.notify()
-
-    def _updateDone(self):
-        """Called when the update is done.
-
-        It checks if we already know the PID, and if not, asks the user whether
-        to register."""
-        if not self.config.pilotID and not self.config.password:
-            dialog = gtk.MessageDialog(parent = self._mainWindow,
-                                       type = MESSAGETYPE_QUESTION,
-                                       message_format = xstr("register_ask"))
-
-            dialog.set_title(WINDOW_TITLE_BASE)
-            dialog.format_secondary_markup(xstr("register_ask_sec"))
-
-            dialog.add_button(xstr("button_cancel"), 0)
-            dialog.add_button(xstr("button_register"), 1)
-            dialog.set_default_response(1)
-
-            result = dialog.run()
-            dialog.hide()
-            if result == 1:
-                self._wizard.jumpPage("register")
Index: src/mlx/gui/monitor.py
===================================================================
--- src/mlx/gui/monitor.py	(revision 680)
+++ src/mlx/gui/monitor.py	(revision 765)
@@ -378,5 +378,8 @@
                 for n1 in aircraftState.n1:
                     if n1Str: n1Str += ", "
-                    n1Str += "%.0f" % (n1,)
+                    if n1 is None:
+                        n1Str += "?"
+                    else:
+                        n1Str += "%.0f" % (n1,)
             elif aircraftState.rpm is not None:
                 n1Str = ""
Index: src/mlx/gui/prefs.py
===================================================================
--- src/mlx/gui/prefs.py	(revision 738)
+++ src/mlx/gui/prefs.py	(revision 684)
@@ -276,6 +276,4 @@
 
         self._updateURL.set_text(config.updateURL)
-
-        self._useRPC.set_active(config.useRPC)
 
         self._settingFromConfig = False
@@ -322,5 +320,4 @@
         config.autoUpdate = self._autoUpdate.get_active()
         config.updateURL = self._updateURL.get_text()
-        config.useRPC = self._useRPC.get_active()
 
     def _buildGeneral(self):
@@ -817,10 +814,4 @@
         updateURLBox.pack_start(self._updateURL, True, True, 4)
 
-        self._useRPC = gtk.CheckButton(xstr("prefs_use_rpc"))
-        mainBox.pack_start(self._useRPC, False, False, 16)
-
-        self._useRPC.set_use_underline(True)
-        self._useRPC.set_tooltip_text(xstr("prefs_use_rpc_tooltip"))
-
         return mainAlignment
 
Index: src/mlx/gui/update.py
===================================================================
--- src/mlx/gui/update.py	(revision 755)
+++ src/mlx/gui/update.py	(revision 300)
@@ -124,5 +124,4 @@
         if not self._waitAfterFinish:
             gobject.idle_add(self._progressWindow.hide)
-            self._gui.updateDone()
 
     def downloadingManifest(self):
@@ -287,6 +286,4 @@
         if self._restart:
             self._gui.restart()
-        else:
-            self._gui.updateDone()
 
 #-------------------------------------------------------------------------------
