Index: src/mlx/acft.py
===================================================================
--- src/mlx/acft.py	(revision 709)
+++ src/mlx/acft.py	(revision 644)
@@ -85,14 +85,4 @@
 #---------------------------------------------------------------------------------------
 
-class SimBriefData(object):
-    """Data to be used when creating SimBrief briefings."""
-    def __init__(self, climbProfiles, cruiseProfiles, descentProfiles):
-        """Construct the SimBrief data with the given profiles."""
-        self.climbProfiles = climbProfiles
-        self.cruiseProfiles = cruiseProfiles
-        self.descentProfiles = descentProfiles
-
-#---------------------------------------------------------------------------------------
-
 class Aircraft(object):
     """Base class for aircraft."""
@@ -133,6 +123,4 @@
         self.maxTouchDownPitch = 15.0
         self.brakeCoolTime = 10.0
-
-        self.simBriefData = None
 
         self._checkers = []
@@ -732,7 +720,4 @@
         self.maxTakeOffPitch = 16.2
         self.maxTouchDownPitch = 14.7
-        self.simBriefData = SimBriefData(["250/280/78"],
-                                         ["CI", "M75", "M78", "M79", "M80", "LRC"],
-                                         ["78/280/250"])
 
 #---------------------------------------------------------------------------------------
@@ -748,7 +733,4 @@
         self.maxTakeOffPitch = 14.7
         self.maxTouchDownPitch = 13.2
-        self.simBriefData = SimBriefData(["250/280/78"],
-                                         ["CI", "M75", "M78", "M79", "M80", "LRC"],
-                                         ["78/280/250", "78/250/250"])
 
 #---------------------------------------------------------------------------------------
@@ -764,7 +746,4 @@
         self.maxTakeOffPitch = 11
         self.maxTouchDownPitch = 9.5
-        self.simBriefData = SimBriefData(["250/280/78"],
-                                         ["CI", "M76", "M78", "M79", "M80", "LRC"],
-                                         ["78/280/250", "78/250/250"])
 
 #---------------------------------------------------------------------------------------
@@ -775,7 +754,4 @@
         super(B738Charter, self).__init__(flight)
         self.mtow = 77791
-        self.simBriefData = SimBriefData(["AUTO"],
-                                         ["280/M74"],
-                                         ["AUTO"])
 
 #---------------------------------------------------------------------------------------
@@ -850,8 +826,4 @@
         self.maxTakeOffPitch = 8.0
         self.maxTouchDownPitch = 7.0
-        self.simBriefData = SimBriefData(["I-900", "II-900", "III-900",
-                                          "I-850", "II-850", "III-850"],
-                                         ["MCR", "ISC", "LRC", "HSC"],
-                                         ["I-850", "II-850", "III-850"])
 
 #---------------------------------------------------------------------------------------
@@ -906,7 +878,4 @@
         self.maxTakeOffPitch = 9.6
         self.maxTouchDownPitch = 8.1
-        self.simBriefData = SimBriefData(["250/290/78"],
-                                         ["CI", "M76", "M78", "M80", "M82", "M84", "LRC"],
-                                         ["78/290/250"])
 
 #---------------------------------------------------------------------------------------
@@ -933,7 +902,4 @@
         self.maxTakeOffPitch = 18.0
         self.maxTouchDownPitch = 18.0
-        self.simBriefData = SimBriefData(["250/70", "290/74"],
-                                         ["CI", "LRC", "M70", "M72", "M74", "M77", "M80"],
-                                         ["74/290/250", "77/320/250"])
 
 #---------------------------------------------------------------------------------------
@@ -1079,7 +1045,4 @@
         self.maxTakeOffPitch = 16.0
         self.maxTouchDownPitch = 16.0
-        self.simBriefData = SimBriefData(["AUTO"],
-                                         ["300/M80"],
-                                         ["AUTO"])
 
     @property
Index: src/mlx/common.py
===================================================================
--- src/mlx/common.py	(revision 651)
+++ src/mlx/common.py	(revision 585)
@@ -18,6 +18,5 @@
 #-------------------------------------------------------------------------------
 
-# Due to CEF, PyGTK is the default
-if "FORCE_PYGOBJECT" not in os.environ:
+if os.name=="nt" or "FORCE_PYGTK" in os.environ:
     print "Using PyGTK"
     pygobject = False
Index: src/mlx/config.py
===================================================================
--- src/mlx/config.py	(revision 689)
+++ src/mlx/config.py	(revision 503)
@@ -211,5 +211,5 @@
 class Config(object):
     """Our configuration."""
-    DEFAULT_UPDATE_URL = "http://mlx.varadiistvan.hu/update/cef"
+    DEFAULT_UPDATE_URL = "http://mlx.varadiistvan.hu/update"
 
     _messageTypesSection = "messageTypes"
@@ -233,9 +233,4 @@
         self._vsSmoothingLength = -2
 
-        self._useSimBrief = False
-        self._simBriefUserName = ""
-        self._simBriefPassword = ""
-        self._rememberSimBriefPassword = False
-
         self._pirepDirectory = None
         self._pirepAutoSave = False
@@ -447,52 +442,4 @@
         if vsSmoothingLength!=self._vsSmoothingLength:
             self._vsSmoothingLength = vsSmoothingLength
-            self._modified = True
-
-    @property
-    def useSimBrief(self):
-        """Check if SimBrief should be used."""
-        return self._useSimBrief
-
-    @useSimBrief.setter
-    def useSimBrief(self, useSimBrief):
-        """Check if SimBrief should be used."""
-        if self._useSimBrief != useSimBrief:
-            self._useSimBrief = useSimBrief
-            self._modified = True
-
-    @property
-    def simBriefUserName(self):
-        """Get the SimBrief user name last used"""
-        return self._simBriefUserName
-
-    @simBriefUserName.setter
-    def simBriefUserName(self, simBriefUserName):
-        """Set the SimBrief user name to be used next."""
-        if self._simBriefUserName != simBriefUserName:
-            self._simBriefUserName = simBriefUserName
-            self._modified = True
-
-    @property
-    def simBriefPassword(self):
-        """Get the SimBrief password last used"""
-        return self._simBriefPassword
-
-    @simBriefPassword.setter
-    def simBriefPassword(self, simBriefPassword):
-        """Set the SimBrief password to be used next."""
-        if self._simBriefPassword != simBriefPassword:
-            self._simBriefPassword = simBriefPassword
-            self._modified = True
-
-    @property
-    def rememberSimBriefPassword(self):
-        """Get if we should remember the SimBrief password."""
-        return self._rememberSimBriefPassword
-
-    @rememberSimBriefPassword.setter
-    def rememberSimBriefPassword(self, rememberSimBriefPassword):
-        """Set if we should remember the SimBrief password."""
-        if rememberSimBriefPassword!=self._rememberSimBriefPassword:
-            self._rememberSimBriefPassword = rememberSimBriefPassword
             self._modified = True
 
@@ -731,15 +678,4 @@
                                                 "vsSmoothingLength",
                                                 -2))
-
-        self._useSimBrief = self._getBoolean(config, "simbrief",
-                                             "use", False)
-        self._simBriefUserName = self._get(config, "simbrief",
-                                           "username", "")
-        self._simBriefPassword = self._get(config, "simbrief",
-                                           "password", "")
-        self._rememberSimBriefPassword = self._getBoolean(config, "simbrief",
-                                                          "rememberPassword",
-                                                          False)
-
         self._pirepDirectory = self._get(config, "general",
                                          "pirepDirectory", None)
@@ -822,12 +758,4 @@
                    str(self._vsSmoothingLength))
 
-        config.add_section("simbrief")
-        config.set("simbrief", "use",
-                   "yes" if self._useSimBrief else "no")
-        config.set("simbrief", "username", self._simBriefUserName)
-        config.set("simbrief", "password", self._simBriefPassword)
-        config.set("simbrief", "rememberPassword",
-                   "yes" if self._rememberSimBriefPassword else "no")
-
         if self._pirepDirectory is not None:
             config.set("general", "pirepDirectory", self._pirepDirectory)
@@ -979,8 +907,4 @@
         print "  vsSmoothingLength:", self._vsSmoothingLength
 
-        print "  useSimBrief:", self._useSimBrief
-        print "  simBriefUserName:", self._simBriefUserName
-        print "  rememberSimBriefPassword:", self._rememberSimBriefPassword
-
         print "  pirepDirectory:", self._pirepDirectory
         print "  pirepAutoSave:", self._pirepAutoSave
Index: src/mlx/const.py
===================================================================
--- src/mlx/const.py	(revision 682)
+++ src/mlx/const.py	(revision 722)
@@ -11,5 +11,5 @@
 
 ## The version of the program
-VERSION="0.35.2cef"
+VERSION="0.36"
 
 #-------------------------------------------------------------------------------
Index: src/mlx/gui/acars.py
===================================================================
--- src/mlx/gui/acars.py	(revision 649)
+++ 	(revision )
@@ -1,36 +1,0 @@
-
-from common import *
-
-from mlx.i18n import xstr
-import mlx.const as const
-
-import cef
-
-#------------------------------------------------------------------------------
-
-## @package mlx.gui.acars
-#
-# The ACARS tab.
-#
-# This module implements to \ref ACRS class, which displays the MAVA ACARS in a
-# browser window using CEF
-
-#------------------------------------------------------------------------------
-
-class ACARS(gtk.VBox):
-    """The flight info tab."""
-    # The URL of the ACARS map
-    URL = "http://virtualairlines.hu/acars2/show.html"
-
-    def __init__(self, gui):
-        """Construct the flight info tab."""
-        super(ACARS, self).__init__()
-        self._gui = gui
-
-    def start(self):
-        """Start the browser."""
-        container = cef.getContainer()
-
-        self.pack_start(container, True, True, 0)
-
-        cef.startInContainer(container, ACARS.URL)
Index: src/mlx/gui/cef.py
===================================================================
--- src/mlx/gui/cef.py	(revision 713)
+++ 	(revision )
@@ -1,441 +1,0 @@
-from common import *
-
-from mava_simbrief import MavaSimbriefIntegrator
-
-from mlx.util import secondaryInstallation
-
-from cefpython3 import cefpython
-from selenium import webdriver
-from selenium.webdriver.chrome.options import Options
-
-import platform
-import json
-import time
-import os
-import re
-import threading
-import tempfile
-import traceback
-
-#------------------------------------------------------------------------------
-
-## @package mlx.gui.cef
-#
-# Some helper stuff related to the Chrome Embedded Framework
-
-#------------------------------------------------------------------------------
-
-# Indicate if we should quit
-_toQuit = False
-
-# Indicate the users of the fast timeout handler. If it reaches zero, the
-# timeout will be stopped
-_fastTimeoutUsers = 0
-
-# The Selenium thread
-_seleniumHandler = None
-
-#------------------------------------------------------------------------------
-
-def getArgsFilePath():
-    """Get the path of the argument file."""
-    if os.name=="nt":
-        return os.path.join(tempfile.gettempdir(),
-                            "mlxcef.args" +
-                            (".secondary" if secondaryInstallation else ""))
-    else:
-        import pwd
-        return os.path.join(tempfile.gettempdir(),
-                            "mlxcef." + pwd.getpwuid(os.getuid())[0] + ".args" +
-                            (".secondary" if secondaryInstallation else ""))
-
-#------------------------------------------------------------------------------
-
-class ArgsFileWaiter(threading.Thread):
-    """A thread to wait for the appearance of the arguments file."""
-    def __init__(self, initializedCallback):
-        """Construct the thread."""
-        threading.Thread.__init__(self)
-        self.daemon = True
-
-        self._initializedCallback = initializedCallback
-
-    def run(self):
-        """Repeatedly check for the existence of the arguments file.
-
-        If it is found, read it, extract the arguments and insert a job into
-        the GUI loop to perform the actual initialization of CEF."""
-        argsFilePath = getArgsFilePath()
-        print "Waiting for the arguments file '%s' to appear" % (argsFilePath,)
-
-        while not os.path.exists(argsFilePath):
-            time.sleep(0.1)
-
-        print "Got arguments, reading them."""
-
-        with open(argsFilePath, "rt") as f:
-            args = f.read().split()
-
-        gobject.idle_add(_initializeCEF, args, self._initializedCallback)
-
-#------------------------------------------------------------------------------
-
-SIMBRIEF_PROGRESS_SEARCHING_BROWSER = MavaSimbriefIntegrator.PROGRESS_SEARCHING_BROWSER
-SIMBRIEF_PROGRESS_LOADING_FORM = MavaSimbriefIntegrator.PROGRESS_LOADING_FORM
-SIMBRIEF_PROGRESS_FILLING_FORM = MavaSimbriefIntegrator.PROGRESS_FILLING_FORM
-SIMBRIEF_PROGRESS_WAITING_LOGIN = MavaSimbriefIntegrator.PROGRESS_WAITING_LOGIN
-SIMBRIEF_PROGRESS_LOGGING_IN = MavaSimbriefIntegrator.PROGRESS_LOGGING_IN
-SIMBRIEF_PROGRESS_WAITING_RESULT = MavaSimbriefIntegrator.PROGRESS_WAITING_RESULT
-
-SIMBRIEF_PROGRESS_RETRIEVING_BRIEFING = MavaSimbriefIntegrator.PROGRESS_MAX + 1
-SIMBRIEF_PROGRESS_DONE = 1000
-
-SIMBRIEF_RESULT_NONE = MavaSimbriefIntegrator.RESULT_NONE
-SIMBRIEF_RESULT_OK = MavaSimbriefIntegrator.RESULT_OK
-SIMBRIEF_RESULT_ERROR_OTHER = MavaSimbriefIntegrator.RESULT_ERROR_OTHER
-SIMBRIEF_RESULT_ERROR_NO_FORM = MavaSimbriefIntegrator.RESULT_ERROR_NO_FORM
-SIMBRIEF_RESULT_ERROR_NO_POPUP = MavaSimbriefIntegrator.RESULT_ERROR_NO_POPUP
-SIMBRIEF_RESULT_ERROR_LOGIN_FAILED = MavaSimbriefIntegrator.RESULT_ERROR_LOGIN_FAILED
-
-#------------------------------------------------------------------------------
-
-class SeleniumHandler(threading.Thread):
-    """Thread to handle Selenium operations."""
-    def __init__(self, programDirectory):
-        """Construct the thread."""
-        threading.Thread.__init__(self)
-        self.daemon = False
-
-        self._programDirectory = programDirectory
-
-        self._commandsCondition = threading.Condition()
-        self._commands = []
-
-        self._driver = None
-
-        self._simBriefBrowser = None
-
-        self._toQuit = False
-
-    @property
-    def programDirectory(self):
-        """Get the program directory."""
-        return self._programDirectory
-
-    @property
-    def simBriefInitURL(self):
-        """Get the initial URL for the SimBrief browser."""
-        return "file://" + os.path.join(self.programDirectory, "simbrief.html")
-
-    def run(self):
-        """Create the Selenium driver and the perform any operations
-        requested."""
-        scriptName = "mlx_cef_caller"
-        if secondaryInstallation:
-            scriptName += "_secondary"
-        scriptName += ".bat" if os.name=="nt" else ".sh"
-
-        scriptPath = os.path.join(self._programDirectory, scriptName)
-        print "Creating the Selenium driver to call script", scriptPath
-
-        options = Options()
-        options.binary_location = scriptPath
-        driver = self._driver = webdriver.Chrome(chrome_options = options)
-        # try:
-        # except:
-        #     traceback.print_exc()
-
-        print "Created Selenium driver."
-        while not self._toQuit:
-            with self._commandsCondition:
-                while not self._commands:
-                    self._commandsCondition.wait()
-
-                command = self._commands[0]
-                del self._commands[0]
-
-            command()
-
-        driver.quit()
-
-    def initializeSimBrief(self):
-        """Create and initialize the browser used for Simbrief."""
-        windowInfo = cefpython.WindowInfo()
-        windowInfo.SetAsOffscreen(int(0))
-
-        url = self.simBriefInitURL
-        self._simBriefBrowser = \
-          cefpython.CreateBrowserSync(windowInfo, browserSettings = {},
-                                      navigateUrl = self.simBriefInitURL)
-        self._simBriefBrowser.SetClientHandler(OffscreenRenderHandler())
-        self._simBriefBrowser.SetFocus(True)
-
-    def callSimBrief(self, plan, getCredentials, updateProgress,
-                     htmlFilePath):
-        """Call SimBrief with the given plan."""
-        self._enqueue(lambda:
-                      self._callSimBrief(plan, self._driver,
-                                         getCredentials, updateProgress,
-                                         htmlFilePath))
-
-    def quit(self):
-        """Instruct the thread to quit and then join it."""
-        self._enqueue(self._quit)
-        self.join()
-
-    def _enqueue(self, command):
-        """Enqueue the given command.
-
-        command should be a function to be executed in the thread."""
-        with self._commandsCondition:
-            self._commands.append(command)
-            self._commandsCondition.notify()
-
-    def _callSimBrief(self, plan, driver,
-                      getCredentials, updateProgress, htmlFilePath):
-        """Perform the SimBrief call."""
-        self._simBriefBrowser.LoadUrl(self.simBriefInitURL)
-
-        integrator = MavaSimbriefIntegrator(plan = plan, driver = driver)
-        link = None
-        try:
-            link = integrator.get_xml_link(getCredentials, updateProgress,
-                                           local_xml_debug = False,
-                                           local_html_debug = False)
-        except Exception, e:
-            print "Failed to initiate the generation of the briefing:", e
-            updateProgress(SIMBRIEF_PROGRESS_RETRIEVING_BRIEFING,
-                           SIMBRIEF_RESULT_ERROR_OTHER, None)
-
-        if link is not None:
-            updateProgress(SIMBRIEF_PROGRESS_RETRIEVING_BRIEFING,
-                           SIMBRIEF_RESULT_NONE, None)
-
-            try:
-                flight_info = integrator.get_results(link,
-                                                     html_file_path =
-                                                     htmlFilePath)
-
-                updateProgress(SIMBRIEF_PROGRESS_DONE,
-                               SIMBRIEF_RESULT_OK, flight_info)
-            except Exception, e:
-                print "Failed to retrieve the briefing:", e
-                updateProgress(SIMBRIEF_PROGRESS_RETRIEVING_BRIEFING,
-                               SIMBRIEF_RESULT_ERROR_OTHER, None)
-
-    def _quit(self):
-        """Set the _toQuit member variable to indicate that the thread should
-        quit."""
-        self._toQuit = True
-
-#------------------------------------------------------------------------------
-
-def initialize(programDirectory, initializedCallback):
-    """Initialize the Chrome Embedded Framework."""
-    global _toQuit, _seleniumHandler
-    _toQuit = False
-
-    gobject.threads_init()
-
-    argsFilePath = getArgsFilePath()
-    try:
-        os.unlink(argsFilePath)
-    except:
-        pass
-
-    _seleniumHandler = SeleniumHandler(programDirectory)
-    _seleniumHandler.start()
-
-    ArgsFileWaiter(initializedCallback).start()
-
-#------------------------------------------------------------------------------
-
-def _initializeCEF(args, initializedCallback):
-    """Perform the actual initialization of CEF using the given arguments."""
-    print "Initializing CEF with args:", args
-
-    settings = {
-        "debug": True, # cefpython debug messages in console and in log_file
-        "log_severity": cefpython.LOGSEVERITY_VERBOSE, # LOGSEVERITY_VERBOSE
-        "log_file": "", # Set to "" to disable
-        "release_dcheck_enabled": True, # Enable only when debugging
-        # This directories must be set on Linux
-        "locales_dir_path": os.path.join(cefpython.GetModuleDirectory(), "locales"),
-        "resources_dir_path": cefpython.GetModuleDirectory(),
-        "browser_subprocess_path": "%s/%s" % \
-            (cefpython.GetModuleDirectory(), "subprocess"),
-    }
-
-    switches={}
-    for arg in args:
-        if arg.startswith("--"):
-            if arg != "--enable-logging":
-                assignIndex = arg.find("=")
-                if assignIndex<0:
-                    switches[arg[2:]] = ""
-                else:
-                    switches[arg[2:assignIndex]] = arg[assignIndex+1:]
-        else:
-            print "Unhandled switch", arg
-
-    cefpython.Initialize(settings, switches)
-
-    gobject.timeout_add(10, _handleTimeout)
-
-    print "Initialized, executing callback..."
-    initializedCallback()
-
-#------------------------------------------------------------------------------
-
-def getContainer():
-    """Get a container object suitable for running a browser instance
-    within."""
-    if os.name=="nt":
-        container = gtk.DrawingArea()
-        container.set_property("can-focus", True)
-        container.connect("size-allocate", _handleSizeAllocate)
-    else:
-        container = gtk.VBox(True, 0)
-
-    container.show()
-
-    return container
-
-#------------------------------------------------------------------------------
-
-def startInContainer(container, url, browserSettings = {}):
-    """Start a browser instance in the given container with the given URL."""
-    if os.name=="nt":
-        windowID = container.get_window().handle
-    else:
-        m = re.search("GtkVBox at 0x(\w+)", str(container))
-        hexID = m.group(1)
-        windowID = int(hexID, 16)
-
-    windowInfo = cefpython.WindowInfo()
-    windowInfo.SetAsChild(windowID)
-
-    return cefpython.CreateBrowserSync(windowInfo,
-                                       browserSettings = browserSettings,
-                                       navigateUrl = url)
-
-#------------------------------------------------------------------------------
-
-class OffscreenRenderHandler(object):
-    def GetRootScreenRect(self, browser, rect):
-        #print "GetRootScreenRect"
-        rect += [0, 0, 800, 600]
-        return True
-
-    def GetViewRect(self, browser, rect):
-        #print "GetViewRect"
-        rect += [0, 0, 800, 600]
-        return True
-
-    def GetScreenPoint(self, browser, viewX, viewY, screenCoordinates):
-        #print "GetScreenPoint", viewX, viewY
-        rect += [viewX, viewY]
-        return True
-
-    def GetScreenInfo(self, browser, screenInfo):
-        #print "GetScreenInfo"
-        pass
-
-    def OnPopupShow(self, browser, show):
-        #print "OnPopupShow", show
-        pass
-
-    def OnPopupSize(self, browser, rect):
-        #print "OnPopupSize", rect
-        pass
-
-    def OnPaint(self, browser, paintElementType, dirtyRects, buffer, width, height):
-        #print "OnPaint", paintElementType, dirtyRects, buffer, width, height
-        pass
-
-    def OnCursorChange(self, browser, cursor):
-        #print "OnCursorChange", cursor
-        pass
-
-    def OnScrollOffsetChanged(self, browser):
-        #print "OnScrollOffsetChange"
-        pass
-
-    def OnBeforePopup(self, browser, frame, targetURL, targetFrameName,
-                      popupFeatures, windowInfo, client, browserSettings,
-                      noJavascriptAccess):
-        wInfo = cefpython.WindowInfo()
-        wInfo.SetAsOffscreen(int(0))
-
-        windowInfo.append(wInfo)
-
-        return False
-
-#------------------------------------------------------------------------------
-
-def initializeSimBrief():
-    """Initialize the (hidden) browser window for SimBrief."""
-    _seleniumHandler.initializeSimBrief()
-
-#------------------------------------------------------------------------------
-
-def callSimBrief(plan, getCredentials, updateProgress, htmlFilePath):
-    """Call SimBrief with the given plan."""
-    _seleniumHandler.callSimBrief(plan, getCredentials,
-                                  updateProgress, htmlFilePath)
-
-#------------------------------------------------------------------------------
-
-def finalize():
-    """Finalize the Chrome Embedded Framework."""
-    global _toQuit, _seleniumHandler
-    toQuit = True
-    cefpython.Shutdown()
-    _seleniumHandler.quit()
-
-#------------------------------------------------------------------------------
-
-def _handleTimeout():
-    """Handle the timeout by running the CEF message loop."""
-    if _toQuit:
-        return False
-    else:
-        cefpython.MessageLoopWork()
-        return True
-
-#------------------------------------------------------------------------------
-
-def startFastTimeout():
-    """Start the fast timeout handler."""
-    global _fastTimeoutUsers
-
-    if _fastTimeoutUsers==0:
-        _fastTimeoutUsers = 1
-        gobject.timeout_add(1, _handleFastTimeout)
-    else:
-        _fastTimeoutUsers += 1
-
-#------------------------------------------------------------------------------
-
-def stopFastTimeout():
-    """Stop the fast timeout handler."""
-    global _fastTimeoutUsers
-
-    assert _fastTimeoutUsers>0
-    _fastTimeoutUsers -= 1
-
-#------------------------------------------------------------------------------
-
-def _handleFastTimeout():
-    """Handle a (fast) timeout by running the CEF message loop."""
-    if _toQuit or _fastTimeoutUsers==0:
-        return False
-    else:
-        cefpython.MessageLoopWork()
-        return True
-
-#------------------------------------------------------------------------------
-
-def _handleSizeAllocate(widget, sizeAlloc):
-    """Handle the size-allocate event."""
-    cefpython.WindowUtils.OnSize(widget.get_window().handle, 0, 0, 0)
Index: src/mlx/gui/common.py
===================================================================
--- src/mlx/gui/common.py	(revision 682)
+++ src/mlx/gui/common.py	(revision 604)
@@ -32,5 +32,4 @@
     pygobject = False
     import pygtk
-    pygtk.require("2.0")
     import gtk.gdk as gdk
     import gtk
Index: src/mlx/gui/flight.py
===================================================================
--- src/mlx/gui/flight.py	(revision 719)
+++ src/mlx/gui/flight.py	(revision 675)
@@ -1,5 +1,4 @@
 
 from mlx.gui.common import *
-import mlx.gui.cef as cef
 
 import mlx.const as const
@@ -18,6 +17,4 @@
 import time
 import os
-import tempfile
-import threading
 
 #-----------------------------------------------------------------------------
@@ -1428,814 +1425,4 @@
 #-----------------------------------------------------------------------------
 
-class RoutePage(Page):
-    """The page containing the route and the flight level."""
-    def __init__(self, wizard):
-        """Construct the page."""
-        super(RoutePage, self).__init__(wizard, xstr("route_title"),
-                                        xstr("route_help"),
-                                        completedHelp = xstr("route_chelp"))
-
-        alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
-                                  xscale = 0.0, yscale = 0.0)
-
-        mainBox = gtk.VBox()
-        alignment.add(mainBox)
-        self.setMainWidget(alignment)
-
-        levelBox = gtk.HBox()
-
-        label = gtk.Label(xstr("route_level"))
-        label.set_use_underline(True)
-        levelBox.pack_start(label, True, True, 0)
-
-        self._cruiseLevel = gtk.SpinButton()
-        self._cruiseLevel.set_increments(step = 10, page = 100)
-        self._cruiseLevel.set_range(min = 0, max = 500)
-        self._cruiseLevel.set_tooltip_text(xstr("route_level_tooltip"))
-        self._cruiseLevel.set_numeric(True)
-        self._cruiseLevel.connect("changed", self._cruiseLevelChanged)
-        self._cruiseLevel.connect("value-changed", self._cruiseLevelChanged)
-        label.set_mnemonic_widget(self._cruiseLevel)
-
-        levelBox.pack_start(self._cruiseLevel, False, False, 8)
-
-        alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
-                                  xscale = 0.0, yscale = 0.0)
-        alignment.add(levelBox)
-
-        mainBox.pack_start(alignment, False, False, 0)
-
-
-        routeBox = gtk.VBox()
-
-        alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
-                                  xscale = 0.0, yscale = 0.0)
-        label = gtk.Label(xstr("route_route"))
-        label.set_use_underline(True)
-        alignment.add(label)
-        routeBox.pack_start(alignment, True, True, 0)
-
-        routeWindow = gtk.ScrolledWindow()
-        routeWindow.set_size_request(400, 80)
-        routeWindow.set_shadow_type(gtk.ShadowType.IN if pygobject
-                                    else gtk.SHADOW_IN)
-        routeWindow.set_policy(gtk.PolicyType.AUTOMATIC if pygobject
-                               else gtk.POLICY_AUTOMATIC,
-                               gtk.PolicyType.AUTOMATIC if pygobject
-                               else gtk.POLICY_AUTOMATIC)
-
-        self._uppercasingRoute = False
-
-        self._route = gtk.TextView()
-        self._route.set_tooltip_text(xstr("route_route_tooltip"))
-        self._route.set_wrap_mode(WRAP_WORD)
-        self._route.get_buffer().connect("changed", self._routeChanged)
-        self._route.get_buffer().connect_after("insert-text", self._routeInserted)
-        routeWindow.add(self._route)
-
-        label.set_mnemonic_widget(self._route)
-        routeBox.pack_start(routeWindow, True, True, 0)
-
-        mainBox.pack_start(routeBox, True, True, 8)
-
-        alternateBox = gtk.HBox()
-
-        label = gtk.Label(xstr("route_altn"))
-        label.set_use_underline(True)
-        alternateBox.pack_start(label, True, True, 0)
-
-        self._alternate = gtk.Entry()
-        self._alternate.set_width_chars(6)
-        self._alternate.connect("changed", self._alternateChanged)
-        self._alternate.set_tooltip_text(xstr("route_altn_tooltip"))
-        label.set_mnemonic_widget(self._alternate)
-
-        alternateBox.pack_start(self._alternate, False, False, 8)
-
-        alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
-                                  xscale = 0.0, yscale = 0.0)
-        alignment.add(alternateBox)
-
-        mainBox.pack_start(alignment, False, False, 0)
-
-        self.addCancelFlightButton()
-
-        self._backButton = self.addPreviousButton(clicked = self._backClicked)
-        self._button = self.addNextButton(clicked = self._forwardClicked)
-
-    @property
-    def filedCruiseLevel(self):
-        """Get the filed cruise level."""
-        return self._cruiseLevel.get_value_as_int()
-
-    @property
-    def route(self):
-        """Get the route."""
-        return self._getRoute()
-
-    @property
-    def alternate(self):
-        """Get the ICAO code of the alternate airport."""
-        return self._alternate.get_text()
-
-    def activate(self):
-        """Setup the route from the booked flight."""
-        self._cruiseLevel.set_value(0)
-        self._cruiseLevel.set_text("")
-        self._route.get_buffer().set_text(self._wizard._bookedFlight.route)
-        self._alternate.set_text("")
-        self._updateForwardButton()
-
-    def _getRoute(self):
-        """Get the text of the route."""
-        buffer = self._route.get_buffer()
-        return buffer.get_text(buffer.get_start_iter(),
-                               buffer.get_end_iter(), True)
-
-    def _updateForwardButton(self):
-        """Update the sensitivity of the forward button."""
-        cruiseLevelText = self._cruiseLevel.get_text()
-        cruiseLevel = int(cruiseLevelText) if cruiseLevelText else 0
-        alternate = self._alternate.get_text()
-        self._button.set_sensitive(cruiseLevel>=50 and self._getRoute()!="" and
-                                   len(alternate)==4)
-
-    def _cruiseLevelChanged(self, *arg):
-        """Called when the cruise level has changed."""
-        self._updateForwardButton()
-
-    def _routeChanged(self, textBuffer):
-        """Called when the route has changed."""
-        if not self._uppercasingRoute:
-            self._updateForwardButton()
-
-    def _routeInserted(self, textBuffer, iter, text, length):
-        """Called when new characters are inserted into the route.
-
-        It uppercases all characters."""
-        if not self._uppercasingRoute:
-            self._uppercasingRoute = True
-
-            iter1 = iter.copy()
-            iter1.backward_chars(length)
-            textBuffer.delete(iter, iter1)
-
-            textBuffer.insert(iter, text.upper())
-
-            self._uppercasingRoute = False
-
-    def _alternateChanged(self, entry):
-        """Called when the alternate airport has changed."""
-        entry.set_text(entry.get_text().upper())
-        self._updateForwardButton()
-
-    def _backClicked(self, button):
-        """Called when the Back button is pressed."""
-        self.goBack()
-
-    def _forwardClicked(self, button):
-        """Called when the Forward button is clicked."""
-        if self._wizard.gui.flight.aircraft.simBriefData is None:
-            self._wizard.usingSimBrief = False
-        if self._wizard.gui.config.useSimBrief and \
-           self._wizard.usingSimBrief is not False:
-            self._wizard.nextPage()
-        else:
-            self._wizard.usingSimBrief = False
-            self._wizard.jumpPage(3)
-
-#-----------------------------------------------------------------------------
-
-class SimBriefCredentialsDialog(gtk.Dialog):
-    """A dialog window to ask for SimBrief credentials."""
-    def __init__(self, gui, userName, password, rememberPassword):
-        """Construct the dialog."""
-        super(SimBriefCredentialsDialog, self).__init__(WINDOW_TITLE_BASE + " - " +
-                                                        xstr("simbrief_credentials_title"),
-                                                        gui.mainWindow,
-                                                        DIALOG_MODAL)
-        self.add_button(xstr("button_cancel"), RESPONSETYPE_CANCEL)
-        self.add_button(xstr("button_ok"), 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)
-
-        label = gtk.Label(xstr("simbrief_login_failed"))
-        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(xstr("simbrief_username"))
-        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)
-        #self._userName.connect("changed",
-        #                       lambda button: self._updateForwardButton())
-        self._userName.set_tooltip_text(xstr("simbrief_username_tooltip"))
-        self._userName.set_text(userName)
-        table.attach(self._userName, 1, 2, 0, 1)
-        label.set_mnemonic_widget(self._userName)
-
-        label = gtk.Label(xstr("simbrief_password"))
-        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(xstr("simbrief_password_tooltip"))
-        self._password.set_text(password)
-        table.attach(self._password, 1, 2, 1, 2)
-        label.set_mnemonic_widget(self._password)
-
-        self._rememberButton = gtk.CheckButton(xstr("simbrief_remember_password"))
-        self._rememberButton.set_use_underline(True)
-        self._rememberButton.set_tooltip_text(xstr("simbrief_remember_tooltip"))
-        self._rememberButton.set_active(rememberPassword)
-        table.attach(self._rememberButton, 1, 2, 2, 3, ypadding = 8)
-
-    @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 self._rememberButton.get_active()
-
-    def run(self):
-        """Run the dialog."""
-        self.show_all()
-
-        response = super(SimBriefCredentialsDialog, self).run()
-
-        self.hide()
-
-        return response
-
-#-----------------------------------------------------------------------------
-
-class SimBriefSetupPage(Page):
-    """Page for setting up some parameters for SimBrief."""
-    monthNum2Name = [
-        "JAN",
-        "FEB",
-        "MAR",
-        "APR",
-        "MAY",
-        "JUN",
-        "JUL",
-        "AUG",
-        "SEP",
-        "OCT",
-        "NOV",
-        "DEC"
-        ]
-
-    progress2Message = {
-        cef.SIMBRIEF_PROGRESS_SEARCHING_BROWSER: "simbrief_progress_searching_browser",
-        cef.SIMBRIEF_PROGRESS_LOADING_FORM: "simbrief_progress_loading_form",
-        cef.SIMBRIEF_PROGRESS_FILLING_FORM: "simbrief_progress_filling_form",
-        cef.SIMBRIEF_PROGRESS_WAITING_LOGIN: "simbrief_progress_waiting_login",
-        cef.SIMBRIEF_PROGRESS_LOGGING_IN: "simbrief_progress_logging_in",
-        cef.SIMBRIEF_PROGRESS_WAITING_RESULT: "simbrief_progress_waiting_result",
-        cef.SIMBRIEF_PROGRESS_RETRIEVING_BRIEFING: "simbrief_progress_retrieving_briefing"
-        }
-
-    result2Message = {
-        cef.SIMBRIEF_RESULT_ERROR_OTHER: "simbrief_result_error_other",
-        cef.SIMBRIEF_RESULT_ERROR_NO_FORM: "simbrief_result_error_no_form",
-        cef.SIMBRIEF_RESULT_ERROR_NO_POPUP: "simbrief_result_error_no_popup",
-        cef.SIMBRIEF_RESULT_ERROR_LOGIN_FAILED: "simbrief_result_error_login_failed"
-        }
-
-    @staticmethod
-    def getHTMLFilePath():
-        """Get the path of the HTML file to contain the generated flight
-        plan."""
-        if os.name=="nt":
-            return os.path.join(tempfile.gettempdir(),
-                                "mlx_simbrief" +
-                                (".secondary" if secondaryInstallation else "") +
-                                ".html")
-        else:
-            import pwd
-            return os.path.join(tempfile.gettempdir(),
-                                "mlx_simbrief." + pwd.getpwuid(os.getuid())[0] + "" +
-                                (".secondary" if secondaryInstallation else "") +
-                                ".html")
-
-    def __init__(self, wizard):
-        """Construct the setup page."""
-
-        super(SimBriefSetupPage, self).__init__(wizard,
-                                                xstr("simbrief_setup_title"),
-                                                xstr("simbrief_setup_help"),
-                                                xstr("simbrief_setup_chelp"))
-
-        alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
-                                  xscale = 0.0, yscale = 0.0)
-
-        table = gtk.Table(9, 3)
-        table.set_row_spacings(4)
-        table.set_col_spacings(16)
-        table.set_homogeneous(False)
-        alignment.add(table)
-        self.setMainWidget(alignment)
-
-        label = gtk.Label(xstr("simbrief_username"))
-        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)
-        self._userName.connect("changed",
-                               lambda button: self._updateForwardButton())
-        self._userName.set_tooltip_text(xstr("simbrief_username_tooltip"))
-        table.attach(self._userName, 1, 2, 0, 1)
-        label.set_mnemonic_widget(self._userName)
-
-        label = gtk.Label(xstr("simbrief_password"))
-        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(xstr("simbrief_password_tooltip"))
-        table.attach(self._password, 1, 2, 1, 2)
-        label.set_mnemonic_widget(self._password)
-
-        self._rememberButton = gtk.CheckButton(xstr("simbrief_remember_password"))
-        self._rememberButton.set_use_underline(True)
-        self._rememberButton.set_tooltip_text(xstr("simbrief_remember_tooltip"))
-        table.attach(self._rememberButton, 1, 2, 2, 3, ypadding = 8)
-
-        self._credentialsCondition = threading.Condition()
-        self._credentialsAvailable = False
-        self._credentialsUserName = None
-        self._credentialsPassword = None
-
-        label = gtk.Label(xstr("simbrief_extra_fuel"))
-        label.set_use_underline(True)
-        label.set_alignment(0.0, 0.5)
-        table.attach(label, 0, 1, 3, 4)
-
-        self._extraFuel = IntegerEntry(defaultValue = 0)
-        self._extraFuel.set_width_chars(6)
-        self._extraFuel.set_tooltip_text(xstr("simbrief_extra_fuel_tooltip"))
-        table.attach(self._extraFuel, 1, 2, 3, 4)
-        label.set_mnemonic_widget(self._extraFuel)
-
-        table.attach(gtk.Label("kg"), 2, 3, 3, 4)
-
-        label = gtk.Label(xstr("simbrief_takeoff_runway"))
-        label.set_use_underline(True)
-        label.set_alignment(0.0, 0.5)
-        table.attach(label, 0, 1, 4, 5)
-
-        self._takeoffRunway = gtk.Entry()
-        self._takeoffRunway.set_width_chars(10)
-        self._takeoffRunway.set_tooltip_text(xstr("simbrief_takeoff_runway_tooltip"))
-        self._takeoffRunway.connect("changed", self._upperChanged)
-        table.attach(self._takeoffRunway, 1, 2, 4, 5)
-        label.set_mnemonic_widget(self._takeoffRunway)
-
-        label = gtk.Label(xstr("simbrief_landing_runway"))
-        label.set_use_underline(True)
-        label.set_alignment(0.0, 0.5)
-        table.attach(label, 0, 1, 5, 6)
-
-        self._landingRunway = gtk.Entry()
-        self._landingRunway.set_width_chars(10)
-        self._landingRunway.set_tooltip_text(xstr("simbrief_takeoff_runway_tooltip"))
-        self._landingRunway.connect("changed", self._upperChanged)
-        table.attach(self._landingRunway, 1, 2, 5, 6)
-        label.set_mnemonic_widget(self._landingRunway)
-
-        label = gtk.Label(xstr("simbrief_climb_profile"))
-        label.set_use_underline(True)
-        label.set_alignment(0.0, 0.5)
-        table.attach(label, 0, 1, 6, 7)
-
-        self._climbProfile = gtk.ComboBox()
-        renderer = gtk.CellRendererText()
-        self._climbProfile.pack_start(renderer, True)
-        self._climbProfile.add_attribute(renderer, "text", 0)
-        self._climbProfile.set_tooltip_text(xstr("simbrief_climb_profile_tooltip"))
-        table.attach(self._climbProfile, 1, 2, 6, 7)
-        label.set_mnemonic_widget(self._climbProfile)
-
-        label = gtk.Label(xstr("simbrief_cruise_profile"))
-        label.set_use_underline(True)
-        label.set_alignment(0.0, 0.5)
-        table.attach(label, 0, 1, 7, 8)
-
-        self._cruiseProfile = gtk.ComboBox()
-        renderer = gtk.CellRendererText()
-        self._cruiseProfile.pack_start(renderer, True)
-        self._cruiseProfile.add_attribute(renderer, "text", 0)
-        self._cruiseProfile.set_tooltip_text(xstr("simbrief_cruise_profile_tooltip"))
-        table.attach(self._cruiseProfile, 1, 2, 7, 8)
-        label.set_mnemonic_widget(self._cruiseProfile)
-
-        label = gtk.Label(xstr("simbrief_descent_profile"))
-        label.set_use_underline(True)
-        label.set_alignment(0.0, 0.5)
-        table.attach(label, 0, 1, 8, 9)
-
-        self._descentProfile = gtk.ComboBox()
-        renderer = gtk.CellRendererText()
-        self._descentProfile.pack_start(renderer, True)
-        self._descentProfile.add_attribute(renderer, "text", 0)
-        self._descentProfile.set_tooltip_text(xstr("simbrief_descent_profile_tooltip"))
-        table.attach(self._descentProfile, 1, 2, 8, 9)
-        label.set_mnemonic_widget(self._descentProfile)
-
-        self.addCancelFlightButton()
-
-        self._backButton = self.addPreviousButton(clicked = self._backClicked)
-        self._button = self.addNextButton(clicked = self._forwardClicked)
-
-    def activate(self):
-        """Activate the SimBrief setup page"""
-        config = self._wizard.gui.config
-
-        self._userName.set_text(config.simBriefUserName)
-        self._userName.set_sensitive(True)
-
-        self._password.set_text(config.simBriefPassword)
-        self._password.set_sensitive(True)
-
-        self._rememberButton.set_active(config.rememberSimBriefPassword)
-        self._rememberButton.set_sensitive(True)
-
-        self._extraFuel.set_int(0)
-        self._extraFuel.set_sensitive(True)
-
-        self._takeoffRunway.set_text("")
-        self._takeoffRunway.set_sensitive(True)
-
-        self._landingRunway.set_text("")
-        self._landingRunway.set_sensitive(True)
-
-        simBriefData = self._wizard.gui.flight.aircraft.simBriefData
-        for (control, profiles) in [(self._climbProfile,
-                                     simBriefData.climbProfiles),
-                                    (self._cruiseProfile,
-                                     simBriefData.cruiseProfiles),
-                                    (self._descentProfile,
-                                     simBriefData.descentProfiles)]:
-            model = gtk.ListStore(str)
-            for profile in profiles:
-                model.append([profile])
-            control.set_model(model)
-            control.set_sensitive(True)
-
-        self._climbProfile.set_active(0)
-        self._cruiseProfile.set_active(0)
-        self._descentProfile.set_active(0)
-
-        self._updateForwardButton()
-
-    def _updateForwardButton(self):
-        """Update the sensitivity of the forward button."""
-        self._button.set_sensitive(len(self._userName.get_text())>0 and
-                                   len(self._password.get_text())>0)
-
-    def _backClicked(self, button):
-        """Called when the Back button is pressed."""
-        self.goBack()
-
-    def _forwardClicked(self, button):
-        if self._completed:
-            self._wizard.nextPage()
-        else:
-            config = self._wizard.gui.config
-
-            config.simBriefUserName = self._userName.get_text()
-
-            rememberPassword = self._rememberButton.get_active()
-            config.simBriefPassword = \
-              self._password.get_text() if rememberPassword else ""
-            config.rememberSimBriefPassword = rememberPassword
-
-            config.save()
-
-            plan = self._getPlan()
-            print "plan:", plan
-
-            takeoffRunway = self._takeoffRunway.get_text()
-            if takeoffRunway:
-                self._wizard.takeoffRunway = takeoffRunway
-
-            landingRunway = self._landingRunway.get_text()
-            if landingRunway:
-                self._wizard.landingRunway = landingRunway
-
-            self._userName.set_sensitive(False)
-            self._password.set_sensitive(False)
-            self._rememberButton.set_sensitive(False)
-            self._extraFuel.set_sensitive(False)
-            self._takeoffRunway.set_sensitive(False)
-            self._landingRunway.set_sensitive(False)
-
-            self._climbProfile.set_sensitive(False)
-            self._cruiseProfile.set_sensitive(False)
-            self._descentProfile.set_sensitive(False)
-
-            self._wizard.gui.beginBusy(xstr("simbrief_calling"))
-
-            cef.startFastTimeout()
-            cef.callSimBrief(plan,
-                             self._getCredentialsCallback,
-                             self._simBriefProgressCallback,
-                             SimBriefSetupPage.getHTMLFilePath())
-
-            startSound(const.SOUND_NOTAM)
-
-    def _getCredentialsCallback(self, count):
-        """Called when the SimBrief home page requests the credentials."""
-        with self._credentialsCondition:
-            self._credentialsAvailable = False
-
-            gobject.idle_add(self._getCredentials, count)
-
-            while not self._credentialsAvailable:
-                self._credentialsCondition.wait()
-
-            return (self._credentialsUserName, self._credentialsPassword)
-
-    def _getCredentials(self, count):
-        """Get the credentials.
-
-        If count is 0, the user name and password entered into the setup page
-        are returned. Otherwise a dialog box is displayed informing the user of
-        invalid credentials and requesting another set of them."""
-        with self._credentialsCondition:
-            if count==0:
-                self._credentialsUserName = self._userName.get_text()
-                self._credentialsPassword = self._password.get_text()
-            else:
-                gui = self._wizard.gui
-                config = gui.config
-
-                dialog = SimBriefCredentialsDialog(gui,
-                                                   config.simBriefUserName,
-                                                   config.simBriefPassword,
-                                                   config.rememberSimBriefPassword)
-                response = dialog.run()
-
-                if response==RESPONSETYPE_OK:
-                    self._credentialsUserName = dialog.userName
-                    self._userName.set_text(self._credentialsUserName)
-                    self._credentialsPassword = dialog.password
-                    self._password.set_text(self._credentialsPassword)
-                    rememberPassword = dialog.rememberPassword
-
-                    config.simBriefUserName = self._credentialsUserName
-
-                    config.simBriefPassword = \
-                        self._credentialsPassword if rememberPassword else ""
-                    config.rememberSimBriefPassword = rememberPassword
-
-                    config.save()
-                else:
-                    self._credentialsUserName = None
-                    self._credentialsPassword = None
-
-            self._credentialsAvailable = True
-            self._credentialsCondition.notify()
-
-    def _simBriefProgressCallback(self, progress, result, flightInfo):
-        """Called by the SimBrief handling thread."""
-        gobject.idle_add(self._simBriefProgress, progress, result, flightInfo)
-
-    def _simBriefProgress(self, progress, result, flightInfo):
-        """The real SimBrief progress handler."""
-        print "_simBriefProgress", progress, result, flightInfo
-        if result==cef.SIMBRIEF_RESULT_NONE:
-            message = SimBriefSetupPage.progress2Message.get(progress,
-                                                             "simbrief_progress_unknown")
-            self._wizard.gui.updateBusyState(xstr(message))
-        else:
-            cef.stopFastTimeout()
-            self._wizard.gui.endBusy()
-
-            if result==cef.SIMBRIEF_RESULT_OK:
-                self._wizard.departureMETARChanged(flightInfo["orig_metar"],
-                                                   self)
-                self._wizard.arrivalMETARChanged(flightInfo["dest_metar"], self)
-                self._wizard.nextPage()
-            else:
-                message = SimBriefSetupPage.result2Message.get(result,
-                                                               "simbrief_result_unknown")
-                dialog = gtk.MessageDialog(parent = self._wizard.gui.mainWindow,
-                                           type = MESSAGETYPE_ERROR,
-                                           message_format =
-                                           xstr(message) + "\n"+
-                                           xstr("simbrief_cancelled"))
-
-                dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
-                dialog.set_title(WINDOW_TITLE_BASE)
-                secondary = xstr("flightsel_save_failed_sec")
-                dialog.format_secondary_markup(secondary)
-                dialog.run()
-                dialog.hide()
-
-                self._wizard.usingSimBrief = False
-                self._wizard.jumpPage(2, fromPageShift = 1)
-
-    def _getPlan(self):
-        """Get the flight plan data for SimBrief."""
-        plan = {
-            "airline": "MAH",
-            "selcal": "XXXX",
-            "fuelfactor": "P000",
-            "contpct": "0.05",
-            "resvrule": "45",
-            "taxiout": "10",
-            "taxiin": "10",
-            "civalue": "AUTO"
-            }
-
-        wizard = self._wizard
-        gui = wizard.gui
-
-        loginResult = wizard.loginResult
-        plan["cpt"] = loginResult.pilotName
-        plan["pid"] = loginResult.pilotID
-
-        bookedFlight = wizard.bookedFlight
-        plan["fltnum"] = wizard.bookedFlight.callsign[2:]
-        plan["type"] = const.icaoCodes[bookedFlight.aircraftType]
-        plan["orig"] = bookedFlight.departureICAO
-        plan["dest"] = bookedFlight.arrivalICAO
-        plan["reg"] = bookedFlight.tailNumber
-        plan["fin"] = bookedFlight.tailNumber[3:]
-        plan["pax"] = str(bookedFlight.numPassengers)
-
-        departureTime = bookedFlight.departureTime
-        plan["date"] = "%d%s%d" % (departureTime.day,
-                                   SimBriefSetupPage.monthNum2Name[departureTime.month-1],
-                                   departureTime.year%100)
-        plan["deph"] = str(departureTime.hour)
-        plan["depm"] = str(departureTime.minute)
-
-        arrivalTime = bookedFlight.arrivalTime
-        plan["steh"] = str(arrivalTime.hour)
-        plan["stem"] = str(arrivalTime.minute)
-
-        plan["manualzfw"] = str(wizard.zfw / 1000.0)
-        plan["cargo"] = str((wizard.bagWeight + wizard.cargoWeight + wizard.mailWeight)/1000.0)
-
-        plan["route"] = wizard.route
-        plan["fl"] = str(wizard.filedCruiseAltitude)
-        plan["altn"] = wizard.alternate
-
-        plan["addedfuel"] = str(self._extraFuel.get_int() / 1000.0)
-        plan["origrwy"] = self._takeoffRunway.get_text()
-        plan["destrwy"] = self._landingRunway.get_text()
-
-        for (key, control) in [("climb", self._climbProfile),
-                               ("cruise", self._cruiseProfile),
-                               ("descent", self._descentProfile)]:
-            model = control.get_model()
-            active = control.get_active_iter()
-            value = model.get_value(active, 0)
-            plan[key] = value
-
-        return plan
-
-    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())
-
-#-----------------------------------------------------------------------------
-
-class SimBriefingPage(Page):
-    """Page to display the SimBrief HTML briefing."""
-    class BrowserLifeSpanHandler(object):
-        """The life-span handler of a browser."""
-        def __init__(self, simBriefingPage):
-            """Construct the life-span handler for the given page."""
-            self._simBriefingPage = simBriefingPage
-
-        def OnBeforeClose(self, browser):
-            """Called before closing the browser."""
-            self._simBriefingPage._invalidateBrowser()
-
-    def __init__(self, wizard):
-        """Construct the setup page."""
-
-        super(SimBriefingPage, self).__init__(wizard,
-                                              "SimBrief flight plan", "")
-
-        self._alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
-                                       xscale = 1.0, yscale = 1.0)
-
-        self._container = cef.getContainer()
-        self._alignment.add(self._container)
-
-        self.setMainWidget(self._alignment)
-
-        self._browser = None
-
-        self.addCancelFlightButton()
-
-        self.addPreviousButton(clicked = self._backClicked)
-
-        self._button = self.addNextButton(clicked = self._forwardClicked)
-        self._button.set_label(xstr("briefing_button"))
-        self._button.set_has_tooltip(False)
-        self._button.set_use_stock(False)
-
-    def activate(self):
-        """Activate the SimBrief flight plan page"""
-        if self._browser is None:
-            self._startBrowser()
-        else:
-            self._browser.Reload()
-
-    def grabDefault(self):
-        """If the page has a default button, make it the default one."""
-        super(SimBriefingPage, self).grabDefault()
-
-        if self._browser is None:
-            self._startBrowser()
-
-    def _backClicked(self, button):
-        """Called when the Back button has been pressed."""
-        self.goBack()
-
-    def _forwardClicked(self, button):
-        """Called when the Forward button has been pressed."""
-        if not self._completed:
-            self._button.set_label(xstr("button_next"))
-            self._button.set_tooltip_text(xstr("button_next_tooltip"))
-            self._wizard.usingSimBrief = True
-            self.complete()
-
-        self._wizard.nextPage()
-
-    def _startBrowser(self):
-        """Start the browser.
-
-        If a container is needed, create one."""
-        if self._container is None:
-            self._container = cef.getContainer()
-            self._alignment.add(self._container)
-
-        url = "file://" + SimBriefSetupPage.getHTMLFilePath()
-        self._browser = cef.startInContainer(self._container, url)
-
-        lifeSpanHandler = SimBriefingPage.BrowserLifeSpanHandler(self)
-        self._browser.SetClientHandler(lifeSpanHandler)
-
-    def _invalidateBrowser(self):
-        """Invalidate the browser (and associated stuff)."""
-        self._alignment.remove(self._container)
-        self._container = None
-        self._browser = None
-
-#-----------------------------------------------------------------------------
-
 class FuelTank(gtk.VBox):
     """Widget for the fuel tank."""
@@ -2473,6 +1660,4 @@
             self._wizard.gui.beginBusy(xstr("fuel_pump_busy"))
             self._pump()
-        elif self._wizard.usingSimBrief:
-            self._wizard.jumpPage(3)
         else:
             self._wizard.nextPage()
@@ -2520,14 +1705,5 @@
         if fuelTank is None:
             self._wizard.gui.endBusy()
-            if self._wizard.usingSimBrief:
-                self._wizard.gui.startMonitoring()
-                self._wizard.jumpPage(3)
-            else:
-                bookedFlight = self._wizard._bookedFlight
-                self._wizard.gui.beginBusy(xstr("route_down_notams"))
-                self._wizard.gui.webHandler.getNOTAMs(self._notamsCallback,
-                                                      bookedFlight.departureICAO,
-                                                      bookedFlight.arrivalICAO)
-                startSound(const.SOUND_NOTAM)
+            self._wizard.nextPage()
         else:
             currentLevel = fuelTank.currentWeight / fuelTank.capacity
@@ -2543,4 +1719,151 @@
                                                       currentLevel)])
             gobject.timeout_add(50, self._pump)
+
+#-----------------------------------------------------------------------------
+
+class RoutePage(Page):
+    """The page containing the route and the flight level."""
+    def __init__(self, wizard):
+        """Construct the page."""
+        super(RoutePage, self).__init__(wizard, xstr("route_title"),
+                                        xstr("route_help"),
+                                        completedHelp = xstr("route_chelp"))
+
+        alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
+                                  xscale = 0.0, yscale = 0.0)
+
+        mainBox = gtk.VBox()
+        alignment.add(mainBox)
+        self.setMainWidget(alignment)
+
+        levelBox = gtk.HBox()
+
+        label = gtk.Label(xstr("route_level"))
+        label.set_use_underline(True)
+        levelBox.pack_start(label, True, True, 0)
+
+        self._cruiseLevel = gtk.SpinButton()
+        self._cruiseLevel.set_increments(step = 10, page = 100)
+        self._cruiseLevel.set_range(min = 0, max = 500)
+        self._cruiseLevel.set_tooltip_text(xstr("route_level_tooltip"))
+        self._cruiseLevel.set_numeric(True)
+        self._cruiseLevel.connect("changed", self._cruiseLevelChanged)
+        self._cruiseLevel.connect("value-changed", self._cruiseLevelChanged)
+        label.set_mnemonic_widget(self._cruiseLevel)
+
+        levelBox.pack_start(self._cruiseLevel, False, False, 8)
+
+        alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
+                                  xscale = 0.0, yscale = 0.0)
+        alignment.add(levelBox)
+
+        mainBox.pack_start(alignment, False, False, 0)
+
+
+        routeBox = gtk.VBox()
+
+        alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
+                                  xscale = 0.0, yscale = 0.0)
+        label = gtk.Label(xstr("route_route"))
+        label.set_use_underline(True)
+        alignment.add(label)
+        routeBox.pack_start(alignment, True, True, 0)
+
+        routeWindow = gtk.ScrolledWindow()
+        routeWindow.set_size_request(400, 80)
+        routeWindow.set_shadow_type(gtk.ShadowType.IN if pygobject
+                                    else gtk.SHADOW_IN)
+        routeWindow.set_policy(gtk.PolicyType.AUTOMATIC if pygobject
+                               else gtk.POLICY_AUTOMATIC,
+                               gtk.PolicyType.AUTOMATIC if pygobject
+                               else gtk.POLICY_AUTOMATIC)
+
+        self._uppercasingRoute = False
+
+        self._route = gtk.TextView()
+        self._route.set_tooltip_text(xstr("route_route_tooltip"))
+        self._route.set_wrap_mode(WRAP_WORD)
+        self._route.get_buffer().connect("changed", self._routeChanged)
+        self._route.get_buffer().connect_after("insert-text", self._routeInserted)
+        routeWindow.add(self._route)
+
+        label.set_mnemonic_widget(self._route)
+        routeBox.pack_start(routeWindow, True, True, 0)
+
+        mainBox.pack_start(routeBox, True, True, 8)
+
+        self.addCancelFlightButton()
+
+        self._backButton = self.addPreviousButton(clicked = self._backClicked)
+        self._button = self.addNextButton(clicked = self._forwardClicked)
+
+    @property
+    def filedCruiseLevel(self):
+        """Get the filed cruise level."""
+        return self._cruiseLevel.get_value_as_int()
+
+    @property
+    def route(self):
+        """Get the route."""
+        return self._getRoute()
+
+    def activate(self):
+        """Setup the route from the booked flight."""
+        self._cruiseLevel.set_value(0)
+        self._cruiseLevel.set_text("")
+        self._route.get_buffer().set_text(self._wizard._bookedFlight.route)
+        self._updateForwardButton()
+
+    def _getRoute(self):
+        """Get the text of the route."""
+        buffer = self._route.get_buffer()
+        return buffer.get_text(buffer.get_start_iter(),
+                               buffer.get_end_iter(), True)
+
+    def _updateForwardButton(self):
+        """Update the sensitivity of the forward button."""
+        cruiseLevelText = self._cruiseLevel.get_text()
+        cruiseLevel = int(cruiseLevelText) if cruiseLevelText else 0
+        self._button.set_sensitive(cruiseLevel>=50 and self._getRoute()!="")
+
+    def _cruiseLevelChanged(self, *arg):
+        """Called when the cruise level has changed."""
+        self._updateForwardButton()
+
+    def _routeChanged(self, textBuffer):
+        """Called when the route has changed."""
+        if not self._uppercasingRoute:
+            self._updateForwardButton()
+
+    def _routeInserted(self, textBuffer, iter, text, length):
+        """Called when new characters are inserted into the route.
+
+        It uppercases all characters."""
+        if not self._uppercasingRoute:
+            self._uppercasingRoute = True
+
+            iter1 = iter.copy()
+            iter1.backward_chars(length)
+            textBuffer.delete(iter, iter1)
+
+            textBuffer.insert(iter, text.upper())
+
+            self._uppercasingRoute = False
+
+    def _backClicked(self, button):
+        """Called when the Back button is pressed."""
+        self.goBack()
+
+    def _forwardClicked(self, button):
+        """Called when the Forward button is clicked."""
+        if self._completed:
+            self._wizard.nextPage()
+        else:
+            bookedFlight = self._wizard._bookedFlight
+            self._wizard.gui.beginBusy(xstr("route_down_notams"))
+            self._wizard.gui.webHandler.getNOTAMs(self._notamsCallback,
+                                                  bookedFlight.departureICAO,
+                                                  bookedFlight.arrivalICAO)
+            startSound(const.SOUND_NOTAM)
 
     def _notamsCallback(self, returned, result):
@@ -3015,8 +2338,5 @@
         self._updatingMETAR = False
 
-        if self._wizard.takeoffRunway is None:
-            self._runway.set_text("")
-        else:
-            self._runway.set_text(self._wizard.takeoffRunway)
+        self._runway.set_text("")
         self._runway.set_sensitive(True)
         self._sid.set_active(0)
@@ -3577,8 +2897,5 @@
         self._transition.set_sensitive(True)
 
-        if self._wizard.landingRunway is None:
-            self._runway.set_text("")
-        else:
-            self._runway.set_text(self._wizard.landingRunway)
+        self._runway.set_text("")
         self._runway.set_sensitive(True)
 
@@ -4261,11 +3578,7 @@
         self._payloadIndex = len(self._pages)
         self._pages.append(TimePage(self))
+        self._pages.append(FuelPage(self))
         self._routePage = RoutePage(self)
         self._pages.append(self._routePage)
-        self._simBriefSetupPage = SimBriefSetupPage(self)
-        self._pages.append(self._simBriefSetupPage)
-        self._simBriefingPage = SimBriefingPage(self)
-        self._pages.append(self._simBriefingPage)
-        self._pages.append(FuelPage(self))
         self._departureBriefingPage = BriefingPage(self, True)
         self._pages.append(self._departureBriefingPage)
@@ -4340,11 +3653,6 @@
         return self._loginResult
 
-    def setCurrentPage(self, index, finalize = False, fromPageShift = None):
-        """Set the current page to the one with the given index.
-
-        @param fromPageShift if given, the relative index of one of the
-        previous pages that should be used as the from-page of the next
-        page. E.g. if fromPageShift is 1, the previous page will be the
-        from-page."""
+    def setCurrentPage(self, index, finalize = False):
+        """Set the current page to the one with the given index."""
         assert index < len(self._pages)
 
@@ -4355,6 +3663,4 @@
                 page.complete()
             self.remove(page)
-            if fromPageShift is not None:
-                fromPage -= fromPageShift
 
         self._currentPage = index
@@ -4435,9 +3741,4 @@
 
     @property
-    def alternate(self):
-        """Get the ICAO code of the alternate airport."""
-        return self._routePage.alternate
-
-    @property
     def departureMETAR(self):
         """Get the METAR of the departure airport."""
@@ -4539,22 +3840,11 @@
         return self._finishPage.online
 
-    @property
-    def usingSimBrief(self):
-        """Indicate if we are using a SimBrief briefing or not."""
-        return self._usingSimBrief
-
-    @usingSimBrief.setter
-    def usingSimBrief(self, x):
-        """Set whether we are using a SimBrief briefing or not."""
-        self._usingSimBrief = x
-
     def nextPage(self, finalize = True):
         """Go to the next page."""
         self.jumpPage(1, finalize)
 
-    def jumpPage(self, count, finalize = True, fromPageShift = None):
+    def jumpPage(self, count, finalize = True):
         """Go to the page which is 'count' pages after the current one."""
-        self.setCurrentPage(self._currentPage + count,
-                            finalize = finalize, fromPageShift = fromPageShift)
+        self.setCurrentPage(self._currentPage + count, finalize = finalize)
 
     def grabDefault(self):
@@ -4605,7 +3895,4 @@
         self._arrivalNOTAMs = None
         self._arrivalMETAR = None
-        self._usingSimBrief = None
-        self.takeoffRunway = None
-        self.landingRunway = None
 
         firstPage = 0 if self._loginResult is None else 1
@@ -4651,9 +3938,9 @@
         metar = metar.upper()
         if originator in [self._departureBriefingPage, self._takeoffPage]:
-            self.departureMETARChanged(metar, originator)
+            self._departureMETARChanged(metar, originator)
         else:
-            self.arrivalMETARChanged(metar, originator)
-
-    def departureMETARChanged(self, metar, originator):
+            self._arrivalMETARChanged(metar, originator)
+
+    def _departureMETARChanged(self, metar, originator):
         """Called when the departure METAR has been edited on one of the
         pages.
@@ -4665,5 +3952,5 @@
                 page.changeMETAR(metar)
 
-    def arrivalMETARChanged(self, metar, originator):
+    def _arrivalMETARChanged(self, metar, originator):
         """Called when the arrival METAR has been edited on one of the
         pages.
Index: src/mlx/gui/gui.py
===================================================================
--- src/mlx/gui/gui.py	(revision 687)
+++ src/mlx/gui/gui.py	(revision 620)
@@ -15,6 +15,4 @@
 from mlx.gui.pirep import PIREPViewer
 from mlx.gui.bugreport import BugReportDialog
-from mlx.gui.acars import ACARS
-import cef
 
 import mlx.const as const
@@ -104,9 +102,6 @@
         window.connect("delete-event", self.deleteMainWindow)
         window.connect("window-state-event", self._handleMainWindowState)
-        if os.name=="nt":
-            window.connect("leave-notify-event", self._handleLeaveNotify)
         accelGroup = gtk.AccelGroup()
         window.add_accel_group(accelGroup)
-        window.realize()
 
         mainVBox = gtk.VBox()
@@ -156,9 +151,4 @@
         self._notebook.append_page(self._fleetGateStatus, label)
 
-        self._acars = ACARS(self)
-        label = gtk.Label("ACARS")
-        label.set_use_underline(True)
-        self._notebook.append_page(self._acars, label)
-
         (self._debugLogWidget, self._debugLogView) = self._buildLogWidget()
         self._debugLogWidget.show_all()
@@ -180,6 +170,4 @@
 
         window.show_all()
-        if os.name=="nt":
-            window.get_window().focus()
 
         self._wizard.grabDefault()
@@ -439,15 +427,11 @@
             self._updater = Updater(self,
                                     self._programDirectory,
-                                    self.config.DEFAULT_UPDATE_URL,
+                                    self.config.updateURL,
                                     self._mainWindow)
             self._updater.start()
-
-        cef.initialize(self._programDirectory, self._cefInitialized)
 
         singleton.raiseCallback = self.raiseCallback
         gtk.main()
         singleton.raiseCallback = None
-
-        cef.finalize()
 
         self._disconnect()
@@ -704,11 +688,4 @@
             self._mainWindow.present()
 
-    def _handleLeaveNotify(self, widget, event):
-        """Handle the leave-notify event.
-
-        Here we reset the focus to the main window as CEF might have acquired
-        it earlier."""
-        self._mainWindow.get_window().focus()
-
     def raiseCallback(self):
         """Callback for the singleton handling code."""
@@ -811,8 +788,4 @@
         self._weightHelp.set_sensitive(False)
         self._mainWindow.get_window().set_cursor(self._busyCursor)
-        self._statusbar.updateBusyState(message)
-
-    def updateBusyState(self, message):
-        """Update the busy state."""
         self._statusbar.updateBusyState(message)
 
@@ -1491,9 +1464,4 @@
                                       summary, description, email)
 
-    def _cefInitialized(self):
-        """Called when CEF has been initialized."""
-        self._acars.start()
-        cef.initializeSimBrief()
-
     def _bugReportSentCallback(self, returned, result):
         """Callback function for the bug report sending result."""
Index: src/mlx/gui/mava_simbrief.py
===================================================================
--- src/mlx/gui/mava_simbrief.py	(revision 701)
+++ 	(revision )
@@ -1,390 +1,0 @@
-# needed for os specific separators
-import os
-# selenium is needed for browser manipulation
-from selenium import webdriver
-from selenium.common.exceptions import NoSuchElementException
-from selenium.common.exceptions import NoSuchWindowException
-from selenium.webdriver.common.by import By
-from selenium.webdriver.support.ui import WebDriverWait, Select
-from selenium.webdriver.support import expected_conditions as EC
-from selenium.webdriver.common.keys import Keys
-# urllib is needed to obtain the xml
-import urllib2
-# xmlparser
-from lxml import etree
-from StringIO import StringIO
-import lxml.html
-import time
-
-
-class MavaSimbriefIntegrator():
-    """Implements the integration with the excellent Simbrief pilot briefing
-    system for MALEV Virtual."""
-
-    # Progress stage: searching the suitable browser window
-    PROGRESS_SEARCHING_BROWSER = 1
-
-    # Progress stage: retrieving the form from the server
-    PROGRESS_LOADING_FORM = 2
-
-    # Progress stage: filling the form
-    PROGRESS_FILLING_FORM = 3
-
-    # Progress stage: waiting for the login
-    PROGRESS_WAITING_LOGIN = 4
-
-    # Progress stage: logging in
-    PROGRESS_LOGGING_IN = 5
-
-    # Progress stage: waiting for result
-    PROGRESS_WAITING_RESULT = 6
-
-    # The maximal reserved progress stage
-    PROGRESS_MAX = 16
-
-    # Result code: none (i.e. the SimBrief query is in progress).
-    RESULT_NONE = 0
-
-    # Result code: success
-    RESULT_OK = 1
-
-    # Result code: other error
-    RESULT_ERROR_OTHER = 2
-
-    # Result code: form could not be loaded
-    RESULT_ERROR_NO_FORM = 11
-
-    # Result code: no popup (i.e. login) window found
-    RESULT_ERROR_NO_POPUP = 12
-
-    # Result code: login failed
-    RESULT_ERROR_LOGIN_FAILED = 13
-
-    # The maximal reserved result code
-    RESULT_MAX = 32
-
-    def __init__(self,
-                 plan,
-                 driver=None,
-                 simbrief_query_settings=None,
-                 mava_simbrief_url=None,
-                 xml_link_fix_part=None):
-        """Init the integrator with settings that are typical of our use.
-        @param: plan - flightplan dictionary
-        @param: webdriver - a selenium webdriver
-        @param: simbrief_query_settings - a dictionary of query settings
-        @param: mava_simbrief_url - url to the form that is sent to simbrief
-        on the mava server
-        @param: xml_link_fix_part = url to the simbrief website under which the
-        xml is to be found"""
-        self.plan = plan
-        if simbrief_query_settings is None:
-            self.simbrief_query_settings = {
-                'navlog': True,
-                'etops': True,
-                'stepclimbs': True,
-                'tlr': True,
-                'notams': True,
-                'firnot': True,
-                'maps': 'Simple',
-            }
-        else:
-            self.simbrief_query_settings = simbrief_query_settings
-
-        if driver is None:
-            self.driver = webdriver.Firefox()
-        else:
-            self.driver = driver
-
-        if mava_simbrief_url is None:
-            self.mava_simbrief_url = "http://flare.privatedns.org/" \
-                                     "mava_simbrief/simbrief_form.html"
-        else:
-            self.mava_simbrief_url = mava_simbrief_url
-
-        if xml_link_fix_part is None:
-            self.xml_link_fix_part = "http://www.simbrief.com/ofp/" \
-                                     "flightplans/xml/"
-        else:
-            self.xml_link_fix_part = xml_link_fix_part
-
-    def fill_form(self,
-                  plan,
-                  simbrief_query_settings):
-        """Fills the form of the webpage using the paramteres that the class
-        has been initialized with.
-        @param: driver - a selenium webdriver
-        @param: plan - dictionary containing plan details
-        @param: simbrief_query_settings - dictionary containing plan settings"""
-        for plan_input_field in plan.iterkeys():
-            self.driver.find_element_by_name(plan_input_field).send_keys(
-                plan[plan_input_field])
-        for option_checkbox in simbrief_query_settings.iterkeys():
-            if (isinstance(simbrief_query_settings[option_checkbox], bool) and
-                    simbrief_query_settings[option_checkbox]):
-                # if setting is a boolean type and true
-                self.driver.find_element_by_name(option_checkbox).click()
-            elif isinstance(simbrief_query_settings[option_checkbox], str):
-                # if setting is a select
-                Select(self.driver.find_element_by_name(option_checkbox)).\
-                    select_by_visible_text(simbrief_query_settings[
-                    option_checkbox])
-
-    def get_xml_link(self,
-                     get_credentials, update_progress,
-                     local_xml_debug=False,
-                     local_html_debug=False):
-        """Obtains the link of the xml to be processed.
-        @param get_credentials - a function, which should return a pair of the
-        user name and password to log in to SimBrief. It gets an integer which
-        is the number of times it has been called so far.
-        @param local_xml_debug - if True then not the real location will be
-        checked but the current working dir will be searched for 'xml.xml'
-        @param local_html_debug - if True then not real mava_simbrief_url will
-        be used but the current working dir will be searched for
-        'mava_simbrief.html'
-        @returns: the string of the xml link if it could be obtained and None
-        otherwise"""
-        # Finding xml_link
-        is_briefing_available = False
-        if local_xml_debug:
-            # set link for locally debugging an existing xml file
-            xml_link = ("file://"
-                        + os.getcwd()
-                        + os.sep
-                        + "xml.xml")
-            is_briefing_available = True
-        else:
-            update_progress(MavaSimbriefIntegrator.PROGRESS_SEARCHING_BROWSER,
-                            MavaSimbriefIntegrator.RESULT_NONE, None)
-            # There must be window whose title is 'SimBrief' so that we
-            # could find our one among several
-            if self._find_window_by_title("SimBrief") is None:
-                print "No SimBrief window was found!"
-                update_progress(MavaSimbriefIntegrator.PROGRESS_SEARCHING_BROWSER,
-                                MavaSimbriefIntegrator.RESULT_ERROR_OTHER, None)
-                return None
-
-            # normal operation with a real xml file
-            update_progress(MavaSimbriefIntegrator.PROGRESS_LOADING_FORM,
-                            MavaSimbriefIntegrator.RESULT_NONE, None)
-            if local_html_debug:
-                self.driver.get(
-                    "file://" + os.getcwd() + os.sep + "simbrief_form.html")
-                is_briefing_available = True
-            else:
-                self.driver.get(self.mava_simbrief_url)
-
-            main_handle = self._find_window_by_title("Malev Virtual Simbrief Integration System")
-            if main_handle is None:
-                print "No SimBrief Integration window was found!"
-                update_progress(MavaSimbriefIntegrator.PROGRESS_LOADING_FORM,
-                                MavaSimbriefIntegrator.RESULT_ERROR_NO_FORM, None)
-                return None
-
-            # Make a copy of the window handles before submitting the form,
-            # so that we could find the popup
-            handles = self.driver.window_handles[:]
-
-            # Entering form data
-            update_progress(MavaSimbriefIntegrator.PROGRESS_FILLING_FORM,
-                            MavaSimbriefIntegrator.RESULT_NONE, None)
-            self.driver.switch_to_window(main_handle)
-            self.fill_form(self.plan,
-                           self.simbrief_query_settings)
-
-            # Loading page
-            button = self.driver.find_element_by_name("submitform")
-            button.send_keys(Keys.RETURN)
-
-            update_progress(MavaSimbriefIntegrator.PROGRESS_WAITING_LOGIN,
-                            MavaSimbriefIntegrator.RESULT_NONE, None)
-            popup_handle = self._find_popup(handles)
-            if popup_handle is None:
-                update_progress(MavaSimbriefIntegrator.PROGRESS_WAITING_LOGIN,
-                                MavaSimbriefIntegrator.RESULT_ERROR_NO_POPUP, None)
-                return None
-
-            login_count = 0
-            end_time = time.time() + 120.0
-            while not is_briefing_available and end_time > time.time():
-                try:
-                    self.driver.switch_to.window(popup_handle)
-
-                    userElement = self.driver.find_element_by_name("user")
-
-                    if userElement is not None:
-                        update_progress(MavaSimbriefIntegrator.PROGRESS_LOGGING_IN,
-                                        MavaSimbriefIntegrator.RESULT_NONE, None)
-                        (userName, password) = get_credentials(login_count)
-                        end_time = time.time() + 120.0
-                        if userName is None or password is None:
-                            update_progress(MavaSimbriefIntegrator.PROGRESS_WAITING_LOGIN,
-                                            MavaSimbriefIntegrator.RESULT_ERROR_LOGIN_FAILED, None)
-                            return None
-
-                        userElement.send_keys(userName)
-                        self.driver.find_element_by_name("pass").send_keys(password)
-                        self.driver.find_element_by_name("staylogged").click()
-
-                        self.driver.find_element(By.XPATH,
-                                                "//input[@value='Login']").send_keys(Keys.RETURN)
-                        login_count += 1
-                except NoSuchElementException:
-                    pass
-                except NoSuchWindowException:
-                    pass
-
-                update_progress(MavaSimbriefIntegrator.PROGRESS_WAITING_RESULT,
-                                MavaSimbriefIntegrator.RESULT_NONE, None)
-                self.driver.switch_to.window(main_handle)
-                try:
-                    if self.driver.find_element_by_name("hidden_is_briefing_available") is not None:
-                        is_briefing_available = True
-                        xml_link_element = self.driver.find_element_by_name(
-                            'hidden_link')
-                        xml_link_generated_part = xml_link_element.get_attribute(
-                            'value')
-                        xml_link = self.xml_link_fix_part + xml_link_generated_part + '.xml'
-                        print(xml_link)
-                except NoSuchElementException:
-                    pass
-
-        if is_briefing_available:
-            return xml_link
-        else:
-            update_progress(MavaSimbriefIntegrator.PROGRESS_WAITING_RESULT,
-                            MavaSimbriefIntegrator.RESULT_ERROR_OTHER, None)
-            return None
-
-    def get_results(self,
-                    xml_link,
-                    html_file_path = None):
-        """Parses the xml for information.
-        @param xml_link - a path to the xml file
-        @return a dictionary of the found information"""
-        # Setup variables
-        ## Holds analysis data not used
-        available_info = {}
-        ## Holds analysis data to be used
-        flight_info = {}
-        ## Holds notams
-        notams_list = []
-        ## Notam counter
-        i = 0
-        # Obtaining the xml
-        response = urllib2.urlopen(xml_link)
-        xml_content = response.read()
-        # Processing xml
-        tree = etree.parse(StringIO(xml_content))
-        context = etree.iterparse(StringIO(xml_content))
-        for action, element in context:
-            # Processing tags that occur multiple times
-            ## NOTAMS
-            if element.tag == 'notamdrec':
-                notams_element_list = list(element)
-                notam_dict = {}
-                for notam in notams_element_list:
-                    notam_dict[notam.tag] = notam.text
-                notams_list.append(notam_dict)
-                i += 1
-            ## WEATHER
-            elif element.tag == 'weather':
-                weather_element_list = list(element)
-                for weather in weather_element_list:
-                    flight_info[weather.tag] = weather.text
-            else:
-                available_info[element.tag] = element.text
-        # Processing plan_html
-        ## Obtaining chart links
-        image_links = []
-        for image_link_a_element in lxml.html.find_class(
-                available_info['plan_html'], 'ofpmaplink'):
-            for image_link_tuple in image_link_a_element.iterlinks():
-                if image_link_tuple[1] == 'src':
-                    image_links.append(image_link_tuple[2])
-        flight_info['image_links'] = image_links
-        print(sorted(available_info.keys()))
-        if html_file_path is None:
-            html_file_path = 'simbrief_plan.html'
-        with open(html_file_path, 'w') as f:
-            f.write(available_info['plan_html'])
-        return flight_info
-
-    def _find_window_by_title(self, title, timeout = 10.0):
-        """Find the window with the given title.
-
-        Switch to that window and return its handle."""
-        def predicate(handle):
-            self.driver.switch_to.window(handle)
-            return self.driver.title == title
-
-        return self._find_window(predicate, timeout = timeout)
-
-    def _find_popup(self, handles, timeout = 10.0):
-        """Find a popup, i.e. a new window being created.
-
-        handles is a list of window handles that existed before the popup was
-        expected to be created. If a new handle is found, that is assumed to be
-        the popup window."""
-        return self._find_window(lambda handle: handle not in handles,
-                                 timeout = timeout)
-
-    def _find_window(self, predicate, timeout = 10.0):
-        """Find a window that fulfills the given predicate."""
-        window_handle = None
-        end_time = time.time() + timeout
-        while window_handle is None and end_time > time.time():
-            for handle in self.driver.window_handles:
-                if predicate(handle):
-                    window_handle = handle
-                    break
-
-        return window_handle
-
-if __name__ == "__main__":
-    mava_simbrief_url = "http://flare.privatedns.org/" \
-                        "mava_simbrief/simbrief_form.html"
-    xml_link_fix_part = "http://www.simbrief.com/ofp/" \
-                        "flightplans/xml/"
-    plan = {
-        'airline': 'MAH',
-        'fltnum': '764',
-        'type': 'B738',
-        'orig': 'LHBP',
-        'dest': 'LSZH',
-        'date': '25FEB15',
-        'deph': '20',
-        'depm': '00',
-        'route': 'GILEP DCT ARSIN UL851 SITNI UL856 NEGRA',
-        'steh': '22',
-        'stem': '05',
-        'reg': 'HA-LOC',
-        'fin': 'LOC',
-        'selcal': 'XXXX',
-        'pax': '100',
-        'altn': 'LSGG',
-        'fl': '36000',
-        'cpt': 'BALINT SZEBENYI',
-        'pid': 'P008',
-        'fuelfactor': 'P000',
-        'manualzfw': '42.7',
-        'addedfuel': '2.5',
-        'contpct': '0.05',
-        'resvrule': '45',
-        'taxiout': '10',
-        'taxiin': '4',
-        'cargo': '5.0',
-        'origrwy': '31L',
-        'destrwy': '34',
-        'climb': '250/300/78',
-        'descent': '80/280/250',
-        'cruise': 'LRC',
-        'civalue': 'AUTO',
-    }
-    integrator = MavaSimbriefIntegrator(plan=plan)
-    link = integrator.get_xml_link(local_xml_debug=False,
-                                   local_html_debug=False)
-    flight_info = integrator.get_results(link)
-    print(flight_info)
-
Index: src/mlx/gui/prefs.py
===================================================================
--- src/mlx/gui/prefs.py	(revision 684)
+++ src/mlx/gui/prefs.py	(revision 392)
@@ -243,6 +243,4 @@
         self._setSmoothing(self._vsSmoothingEnabled, self._vsSmoothingLength,
                            config.vsSmoothingLength)
-
-        self._useSimBrief.set_active(config.useSimBrief)
 
         pirepDirectory = config.pirepDirectory
@@ -293,5 +291,4 @@
         config.vsSmoothingLength = self._getSmoothing(self._vsSmoothingEnabled,
                                                        self._vsSmoothingLength)
-        config.useSimBrief = self._useSimBrief.get_active()
         config.pirepDirectory = text2unicode(self._pirepDirectory.get_text())
         config.pirepAutoSave = self._pirepAutoSave.get_active()
@@ -409,9 +406,4 @@
                                     xstr("prefs_vsSmoothingEnabledTooltip"))
         simulatorBox.pack_start(vsSmoothingBox, False, False, 4)
-
-        self._useSimBrief = gtk.CheckButton(xstr("prefs_useSimBrief"))
-        self._useSimBrief.set_use_underline(True)
-        self._useSimBrief.set_tooltip_text(xstr("prefs_useSimBrief_tooltip"))
-        mainBox.pack_start(self._useSimBrief, False, False, 0)
 
         pirepBox = gtk.HBox()
Index: src/mlx/update.py
===================================================================
--- src/mlx/update.py	(revision 681)
+++ src/mlx/update.py	(revision 672)
@@ -525,4 +525,6 @@
         return
 
+    print "update: result:", result
+
     (manifest, updateManifest, modifiedAndNew, removed) = result        
     localRemoved = getToremoveFiles(directory)
