Version bump

[gc-dialer] / src / dc_glade.py

diff --git a/src/dc_glade.py b/src/dc_glade.py
index 11f3d5a..9a2e3d7 100755 (executable)
--- a/src/dc_glade.py
+++ b/src/dc_glade.py
@@ -20,8 +20,13 @@
 
 """
 DialCentral: A phone dialer using GrandCentral
+
+@todo Add logging support to make debugging issues for people a lot easier
 """
 
+
+from __future__ import with_statement
+
 import sys
 import gc
 import os
@@ -51,7 +56,7 @@ class Dialcentral(object):
 
        __pretty_app_name__ = "DialCentral"
        __app_name__ = "dialcentral"
-       __version__ = "0.9.2"
+       __version__ = "0.9.6"
        __app_magic__ = 0xdeadbeef
 
        _glade_files = [
@@ -81,7 +86,7 @@ class Dialcentral(object):
                self._recentViews = None
                self._contactsViews = None
 
-               for path in Dialcentral._glade_files:
+               for path in self._glade_files:
                        if os.path.isfile(path):
                                self._widgetTree = gtk.glade.XML(path)
                                break
@@ -147,8 +152,7 @@ class Dialcentral(object):
                import null_views
 
                self._phoneBackends = {self.NULL_BACKEND: null_backend.NullDialer()}
-               gtk.gdk.threads_enter()
-               try:
+               with gtk_toolbox.gtk_lock():
                        self._dialpads = {self.NULL_BACKEND: null_views.Dialpad(self._widgetTree)}
                        self._accountViews = {self.NULL_BACKEND: null_views.AccountInfo(self._widgetTree)}
                        self._recentViews = {self.NULL_BACKEND: null_views.RecentCallsView(self._widgetTree)}
@@ -158,8 +162,6 @@ class Dialcentral(object):
                        self._accountViews[self._selectedBackendId].enable()
                        self._recentViews[self._selectedBackendId].enable()
                        self._contactsViews[self._selectedBackendId].enable()
-               finally:
-                       gtk.gdk.threads_leave()
 
                # Setup maemo specifics
                try:
@@ -209,8 +211,7 @@ class Dialcentral(object):
                        self.GC_BACKEND: gc_backend.GCDialer(gcCookiePath),
                        self.GV_BACKEND: gv_backend.GVDialer(gvCookiePath),
                })
-               gtk.gdk.threads_enter()
-               try:
+               with gtk_toolbox.gtk_lock():
                        unifiedDialpad = gc_views.Dialpad(self._widgetTree, self._errorDisplay)
                        unifiedDialpad.set_number("")
                        self._dialpads.update({
@@ -241,8 +242,6 @@ class Dialcentral(object):
                                        self._widgetTree, self._phoneBackends[self.GV_BACKEND], self._errorDisplay
                                ),
                        })
-               finally:
-                       gtk.gdk.threads_leave()
 
                evoBackend = evo_backend.EvolutionAddressBook()
                fsContactsPath = os.path.join(self._data_path, "contacts")
@@ -285,7 +284,7 @@ class Dialcentral(object):
                if not self._deviceIsOnline:
                        warnings.warn("Attempted to login while device was offline")
                        return False
-               elif self._phoneBackends is None:
+               elif self._phoneBackends is None or len(self._phoneBackends) < len(self.BACKENDS):
                        warnings.warn(
                                "Attempted to login before initialization is complete, did an event fire early?"
                        )
@@ -299,29 +298,23 @@ class Dialcentral(object):
                        for x in xrange(numOfAttempts):
                                if loggedIn:
                                        break
-                               gtk.gdk.threads_enter()
-                               try:
+                               with gtk_toolbox.gtk_lock():
                                        availableServices = {
                                                self.GV_BACKEND: "Google Voice",
                                                self.GC_BACKEND: "Grand Central",
                                        }
                                        credentials = self._credentials.request_credentials_from(availableServices)
                                        serviceId, username, password = credentials
-                               finally:
-                                       gtk.gdk.threads_leave()
 
                                loggedIn = self._phoneBackends[serviceId].login(username, password)
                except RuntimeError, e:
                        warnings.warn(traceback.format_exc())
-                       self._errorDisplay.push_message_with_lock(e.message)
+                       self._errorDisplay.push_exception_with_lock(e)
 
-               gtk.gdk.threads_enter()
-               try:
+               with gtk_toolbox.gtk_lock():
                        if not loggedIn:
                                self._errorDisplay.push_message("Login Failed")
                        self._change_loggedin_status(serviceId if loggedIn else self.NULL_BACKEND)
-               finally:
-                       gtk.gdk.threads_leave()
                return loggedIn
 
        def display_error_message(self, msg):
@@ -333,8 +326,9 @@ class Dialcentral(object):
                error_dialog.connect("response", close, self)
                error_dialog.run()
 
-       @staticmethod
-       def _on_close(*args, **kwds):
+       def _on_close(self, *args, **kwds):
+               if self._osso is not None:
+                       self._osso.close()
                gtk.main_quit()
 
        def _change_loggedin_status(self, newStatus):
@@ -391,13 +385,11 @@ class Dialcentral(object):
                bearer = event.get_bearer_type()
 
                if status == conic.STATUS_CONNECTED:
-                       self._window.set_sensitive(True)
                        self._deviceIsOnline = True
                        backgroundLogin = threading.Thread(target=self.attempt_login, args=[2])
                        backgroundLogin.setDaemon(True)
                        backgroundLogin.start()
                elif status == conic.STATUS_DISCONNECTED:
-                       self._window.set_sensitive(False)
                        self._deviceIsOnline = False
                        self._defaultBackendId = self._selectedBackendId
                        self._change_loggedin_status(self.NULL_BACKEND)
@@ -455,9 +447,8 @@ class Dialcentral(object):
                try:
                        loggedIn = self._phoneBackends[self._selectedBackendId].is_authed()
                except RuntimeError, e:
-                       warnings.warn(traceback.format_exc())
                        loggedIn = False
-                       self._errorDisplay.push_message(e.message)
+                       self._errorDisplay.push_exception(e)
                        return
 
                if not loggedIn:
@@ -472,11 +463,9 @@ class Dialcentral(object):
                        self._phoneBackends[self._selectedBackendId].dial(number)
                        dialed = True
                except RuntimeError, e:
-                       warnings.warn(traceback.format_exc())
-                       self._errorDisplay.push_message(e.message)
+                       self._errorDisplay.push_exception(e)
                except ValueError, e:
-                       warnings.warn(traceback.format_exc())
-                       self._errorDisplay.push_message(e.message)
+                       self._errorDisplay.push_exception(e)
 
                if dialed:
                        self._dialpads[self._selectedBackendId].clear()