← Back to branch summary

~freenx-team/freenx-server/eagleeye

« back to all changes in this revision

Viewing changes to eagleeye/eagleeye.py

  • Committer: Marcelo Boveto Shima
  • Date: 2009-04-22 22:03:42 UTC
  • Revision ID: marceloshima@gmail.com-20090422220342-zw2q62avji348h2r
Interface changes and lots of gconf manipulation fixes

Show diffs side-by-side

added added

removed removed

Lines of Context:
eagleeye/eagleeye.py
65
65
                self.dialog = self.wTree.get_object("connectDialog")
66
66
                self.about = self.wTree.get_object("aboutDialog")
67
67
                self.about.set_version(version)
 
68
                self.sessionNameDialog = self.wTree.get_object("sessionNameDialog")
68
69
                self.iconview = self.wTree.get_object("iconview1")
69
70
 
70
 
 
71
 
                self.model = gtk.ListStore (str,str,str,gtk.gdk.Pixbuf)
 
71
                self.model = gtk.ListStore (str,gtk.gdk.Pixbuf,str,str,str)
72
72
                self.iconview.set_model(self.model)
73
73
                self.iconview.set_text_column(0)
74
 
                self.iconview.set_pixbuf_column(3)
 
74
                self.iconview.set_pixbuf_column(1)
75
75
                self.helpMenu = self.wTree.get_object("helpMenu")
76
76
                self.helpButton = self.wTree.get_object("helpButton")
77
77
                self.helpMenu.attach_to_widget(self.helpButton, None)
89
89
                                "on_aboutDialog_delete_event" : self.hide_about_dialog,
90
90
                                "on_connectButton_clicked" : self.connect,
91
91
                                "on_addButton_clicked" : self.add_server,
 
92
                                "on_cancelAddButton_clicked" : self.hideSessionNameDialog,
 
93
                                "on_saveSessionButton_clicked" : self.save_server,
92
94
                                "on_iconview1_selection_changed" : self.selected,
93
95
                                "on_iconview1_item_activated" : self.activated,
94
96
                                "on_delButton_clicked" : self.delete_clicked,
98
100
                        self.dialog.show()
99
101
                
100
102
                #read stored credentials
101
 
                GCONF_AUTH_KEY = "/apps/eagleeye"
102
 
                keyring = gnomekeyring.get_default_keyring_sync()
 
103
                GCONF_AUTH_KEY = "/apps/eagleeye/sessions"
103
104
                gconfclient = gconf.client_get_default()
104
105
                gconfclient.add_dir (GCONF_AUTH_KEY,
105
106
                        gconf.CLIENT_PRELOAD_RECURSIVE)
106
 
                entries = gconfclient.all_entries(GCONF_AUTH_KEY)
107
 
                if len(entries) == 0:
 
107
                dirs = gconfclient.all_dirs(GCONF_AUTH_KEY)
 
108
                pixbuf = self.iconview.render_icon(gtk.STOCK_NETWORK, gtk.ICON_SIZE_BUTTON)
 
109
                self.model.append(['Custom', pixbuf, '', '', ''])
 
110
                if len(dirs) == 0:
108
111
                        return #found nothing
109
 
                for i in range(len(entries)):
110
 
                        server = entries[i].get_key()
111
 
                        server = server.replace (GCONF_AUTH_KEY+"/", "")
112
 
                        auth_token = entries[i].get_value().get_int()
113
 
                        if auth_token > 0:
114
 
                                try:
115
 
                                        secret = gnomekeyring.item_get_info_sync(keyring, auth_token).get_secret()
116
 
                                except gnomekeyring.DeniedError:
117
 
                                        username = None
118
 
                                        password = None
119
 
                                        auth_token = 0
120
 
                                        print _("gnome-keyring access denied")
 
112
                for i in range(len(dirs)):
 
113
                        props = {}
 
114
                        for prop in ('server_address', 'session_name', 'username', 'profile'):
 
115
                                value = gconfclient.get_entry(dirs[i]+"/"+prop,"", False).get_value()
 
116
                                if value is not None:
 
117
                                        props[prop] = value.get_string()
121
118
                                else:
122
 
                                        username, password = secret.split('\n')
123
 
                        else:
124
 
                                username = None
125
 
                                password = None
126
 
                        pixbuf = self.iconview.render_icon(gtk.STOCK_NETWORK, gtk.ICON_SIZE_BUTTON)
127
 
                        self.model.append([server, username, password, pixbuf])
 
119
                                        props[prop] = ""
 
120
                        self.model.append([props['session_name'], pixbuf, props['server_address'], props['username'], props['profile']])
128
121
 
129
122
                #if a server was specified at startup, connect to it
130
123
                if self.startup_options.server:
151
144
 
152
145
                i = select[0][0]
153
146
                iter = self.model.get_iter(i)
154
 
                s = self.model.get(iter,0,1,2)
155
 
                server = s[0]
 
147
                s = self.model.get(iter,0, 2, 3)
 
148
                session = s[0]
156
149
                
157
150
                #ask confirmation
158
151
                dialog = gtk.MessageDialog (self.dialog,
159
152
                        gtk.MESSAGE_QUESTION,
160
153
                        gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
161
154
                        gtk.BUTTONS_YES_NO,
162
 
                        _("Are you sure you want remove the server \"%(server)s\"?") %{"server": server})
 
155
                        _("Are you sure you want remove the session \"%s\"?") % session)
163
156
                r = dialog.run()
164
157
                dialog.destroy()
165
158
                if (r == gtk.RESPONSE_NO):
166
159
                        print _("deletion canceled")
167
160
                else:
168
 
                        GCONF_AUTH_KEY = "/apps/eagleeye"       
 
161
                        GCONF_AUTH_KEY = "/apps/eagleeye/sessions"
169
162
                        gconfclient = gconf.client_get_default()
170
163
                        gconfclient.add_dir (GCONF_AUTH_KEY,
171
164
                                gconf.CLIENT_PRELOAD_RECURSIVE)
172
 
                        entry = gconfclient.get_entry(GCONF_AUTH_KEY+"/"+server,
173
 
                                "", False)
174
 
                        server = entry.get_key()
175
 
                        server = server.replace (GCONF_AUTH_KEY+"/", "")
176
 
                        auth_token = entry.get_value().get_int()
 
165
                        session_name = gconfclient.get_entry(GCONF_AUTH_KEY+"/session_name","", False).get_value().get_string()
 
166
                        auth_token = gconfclient.get_entry(GCONF_AUTH_KEY+"/keyring_token","", False).get_value().get_int()
177
167
                        if auth_token > 0:
178
168
                                try:
179
169
                                        #delete gnome-keyring entry
180
170
                                        keyring = gnomekeyring.get_default_keyring_sync()
181
171
                                        gnomekeyring.item_delete_sync(keyring, auth_token)
182
172
                                        #delete gconf entry
183
 
                                        gconfclient.unset(GCONF_AUTH_KEY+"/"+server)
 
173
                                        gconfclient.recursive_unset(GCONF_AUTH_KEY+"/"+session_name)
184
174
                                        #remove from icon view
185
 
                                        select = self.iconview.get_selected_items()
186
 
                                        if len(select) == 0:
187
 
                                                return
188
 
                                        i = select[0][0]
189
 
                                        iter = self.model.get_iter(i)
190
175
                                        self.model.remove(iter)
191
 
                                        print server+" deleted"
 
176
                                        print session_name+" deleted"
192
177
                                except gnomekeyring.DeniedError:
193
178
                                        auth_token = 0
194
179
                                        print _("gnome-keyring access denied, could not delete")
199
184
                self.connect(widget)
200
185
 
201
186
        def selected (self, data):
202
 
                username = self.wTree.get_object("usernameEntry")
203
 
                password = self.wTree.get_object("pwdEntry")
204
 
                server = self.wTree.get_object("serverEntry")
205
187
                select = self.iconview.get_selected_items()
206
188
                if len(select) == 0:
207
189
                        return
208
190
                i = select[0][0]
209
191
                iter = self.model.get_iter(i)
210
 
                s = self.model.get(iter,0,1,2)
211
 
                server.set_text(s[0])
212
 
                if (s[1] != None):
213
 
                        username.set_text(s[1])
214
 
                else:
215
 
                        username.set_text("")
216
 
                if (s[2] != None):
217
 
                        password.set_text(s[2])
218
 
                else:
219
 
                        password.set_text("")
 
192
                s = self.model.get(iter,0, 2, 3)
 
193
                self.wTree.get_object("serverEntry").set_text(s[1])
 
194
                if s[0] == "Custom":
 
195
                        self.wTree.get_object("serverEntry").set_editable(True)
 
196
                        self.wTree.get_object("sessionNameEntry").set_text("")
 
197
                else:
 
198
                        self.wTree.get_object("serverEntry").set_editable(False)
 
199
                        self.wTree.get_object("sessionNameEntry").set_text(s[0])
 
200
                self.wTree.get_object("usernameEntry").set_text(s[2])
 
201
                self.wTree.get_object("pwdEntry").set_text("")
 
202
 
220
203
 
221
204
        #finds the server 'name', and return its credentials and its iconview path
222
205
        #if not found, return False
223
206
        def find_server (self, name):
224
207
                iter = self.model.get_iter_first()
225
208
                while (iter != None):
226
 
                        row = self.model.get(iter, 0, 1, 2)  #server, username, pwd
 
209
                        row = self.model.get(iter, 0)  #server
227
210
                        if row[0] == name:
228
211
                                row += ( self.model.get_path(iter), )
229
212
                                return row
230
213
                        iter = self.model.iter_next(iter)
231
214
                return False
232
215
        
 
216
        def hideSessionNameDialog (self, data):
 
217
                self.sessionNameDialog.hide()
 
218
                select = self.iconview.get_selected_items()
 
219
                if len(select) == 0:
 
220
                        self.wTree.get_object("sessionNameEntry").set_text("")
 
221
                        return
 
222
                i = select[0][0]
 
223
                iter = self.model.get_iter(i)
 
224
                s = self.model.get(iter,0, 2, 3)
 
225
                if s[0] == "Custom":
 
226
                        self.wTree.get_object("sessionNameEntry").set_text("")
 
227
                else:
 
228
                        self.wTree.get_object("sessionNameEntry").set_text(s[1])
 
229
 
233
230
        def add_server (self, data):
 
231
                server = self.wTree.get_object("serverEntry").get_text()
 
232
                if server == "":
 
233
                        return
 
234
                sessionName = self.wTree.get_object("sessionNameEntry").get_text()
 
235
                if sessionName == "":
 
236
                        sessionName = server
 
237
                self.wTree.get_object("sessionNameEntry").set_text(sessionName)
 
238
                self.sessionNameDialog.show()
 
239
 
 
240
        def save_server (self, data):
 
241
                self.sessionNameDialog.hide()
234
242
                #add it to the iconview
235
243
                pixbuf = self.iconview.render_icon(gtk.STOCK_NETWORK, gtk.ICON_SIZE_BUTTON)
236
244
                username = self.wTree.get_object("usernameEntry").get_text()
237
245
                password = self.wTree.get_object("pwdEntry").get_text()
238
246
                server = self.wTree.get_object("serverEntry").get_text()
239
 
                if server == "":
240
 
                        return
241
 
                self.model.append([server, username, password, pixbuf])
 
247
                session = self.wTree.get_object("sessionNameEntry").get_text()
 
248
                profile = 'nx'
 
249
                if session == "":
 
250
                        session = server
 
251
                self.model.append([session, pixbuf, server, username, profile])
242
252
 
243
253
                #now save it in gnome-keyring
244
 
                GCONF_AUTH_KEY = "/apps/eagleeye/"+server
 
254
                GCONF_AUTH_KEY = "/apps/eagleeye/sessions/"+session
245
255
                keyring = gnomekeyring.get_default_keyring_sync()
246
256
                auth_token = gnomekeyring.item_create_sync(
247
257
                        keyring,
248
258
                        gnomekeyring.ITEM_GENERIC_SECRET,
249
 
                        "eagleeye VNC server credentials ("+server+")",
250
 
                        dict(appname="eagleeye, credentials of vnc server \""+server+"\""),
251
 
                        "\n".join((username, password)), True)
252
 
                gconf.client_get_default().set_int(GCONF_AUTH_KEY, auth_token)
 
259
                        "Password for "+session+" remote desktop session",
 
260
                        dict(appname="eagleeye, credentials of remote desktop session \""+session+"\""),
 
261
                        password, True)
 
262
                gconf.client_get_default().set_string(GCONF_AUTH_KEY+'/profile', profile)
 
263
                gconf.client_get_default().set_string(GCONF_AUTH_KEY+'/session_name', session)
 
264
                gconf.client_get_default().set_string(GCONF_AUTH_KEY+'/server_address', server)
 
265
                gconf.client_get_default().set_string(GCONF_AUTH_KEY+'/username', username)
 
266
                gconf.client_get_default().set_int(GCONF_AUTH_KEY+'/keyring_token', auth_token)
253
267
 
254
268
        def handle_about_dialog_answer(self, widget, data):
255
269
                if(data==-6):
262
276
                self.about.hide()
263
277
                return True
264
278
 
 
279
        def get_gconf_key(self):
 
280
                session_name = self.wTree.get_object("sessionNameEntry").get_text()
 
281
                if session_name == '':
 
282
                        return None
 
283
                GCONF_AUTH_KEY = "/apps/eagleeye/sessions/" + session_name
 
284
                gconfclient = gconf.client_get_default()
 
285
                entry = gconfclient.get_entry(GCONF_AUTH_KEY+"/server_address",
 
286
                        "", False)
 
287
                server = entry.get_value().get_string()
 
288
 
 
289
                if server == self.wTree.get_object("serverEntry").get_text():
 
290
                        return GCONF_AUTH_KEY
 
291
                return None
 
292
 
265
293
        def connect(self, window):
266
294
                self.dialog.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))
267
295
                username = self.wTree.get_object("usernameEntry").get_text()
268
296
                password = self.wTree.get_object("pwdEntry").get_text()
 
297
                GCONF_AUTH_KEY = self.get_gconf_key()
 
298
                if password == '' and GCONF_AUTH_KEY is not None:
 
299
                        # Get the password
 
300
                        gconfclient = gconf.client_get_default()
 
301
                        gconfclient.add_dir (GCONF_AUTH_KEY,
 
302
                                gconf.CLIENT_PRELOAD_RECURSIVE)
 
303
                        entry = gconfclient.get_entry(GCONF_AUTH_KEY+"/keyring_token","", False)
 
304
                        auth_token = entry.get_value().get_int()
 
305
 
 
306
                        password = ""
 
307
                        if auth_token > 0:
 
308
                                try:
 
309
                                        keyring = gnomekeyring.get_default_keyring_sync()
 
310
                                        password = gnomekeyring.item_get_info_sync(keyring, auth_token).get_secret()
 
311
                                except gnomekeyring.DeniedError:
 
312
                                        auth_token = 0
 
313
                                        print _("gnome-keyring access denied")
 
314
 
 
315
 
269
316
                server = self.wTree.get_object("serverEntry").get_text()
270
317
                print _("Connecting to %s...") % server 
271
318
                serverport = server.split(':')