← Back to branch summary

~ubuntu-branches/ubuntu/lucid/gco/lucid

« back to all changes in this revision

Viewing changes to src/co.py

  • Committer: Bazaar Package Importer
  • Author(s): Sam Hocevar (Debian packages)
  • Date: 2006-08-31 12:35:42 UTC
  • mfrom: (3.1.2 edgy)
  • Revision ID: james.westby@ubuntu.com-20060831123542-mc4q70vmhci7jkx7
Tags: 0.5.0-6
http://bugs.debian.org/380807
Update package to the last python policy, courtesy of Pierre Habouzit
(Closes: #380807).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/co.py
 
1
#!/usr/bin/python
 
2
 
 
3
##   GNOME Comics Organizer - Python Branch
 
4
##   Copyright (C) 2004 Mads Villadsen <maxximum@krakoa.dk>
 
5
    
 
6
##   This program is free software; you can redistribute it and/or modify
 
7
##   it under the terms of the GNU General Public License as published by
 
8
##   the Free Software Foundation; either version 2 of the License, or
 
9
##   (at your option) any later version.
 
10
   
 
11
##   This program is distributed in the hope that it will be useful,
 
12
##   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
##   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
##   GNU General Public License for more details.
 
15
   
 
16
##   You should have received a copy of the GNU General Public License
 
17
##   along with this program; if not, write to the Free Software
 
18
##   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
19
 
 
20
import comiclist
 
21
import fileops
 
22
from globals import *
 
23
 
 
24
import gobject
 
25
import sys
 
26
import pango
 
27
import cgi
 
28
import os.path
 
29
import string
 
30
 
 
31
try:
 
32
    import pygtk
 
33
    pygtk.require ("2.0")
 
34
    import gtk, gtk.glade, gnome, gnome.ui
 
35
except:
 
36
    print "pyGTK 2.0 not found."
 
37
 
 
38
COMICS_COLUMN_TITLE = 0
 
39
COMICS_COLUMN_PUBLISHER = 1
 
40
COMICS_COLUMN_COMIC_ID_HIDDEN = 2
 
41
COMICS_COLUMN_ISSUE_ID_HIDDEN = 3
 
42
 
 
43
class gco_mainwindow:
 
44
    def __init__(self):
 
45
        self.comics = []
 
46
        self.filename = None
 
47
        self.file_modified = False
 
48
        self.uuid_gen = comiclist.uuid_generator(0)
 
49
        self.highest_uuid = str(0)
 
50
        self.wTree = None
 
51
        try:
 
52
            self.wTree = gtk.glade.XML (gladefile, "main_window")
 
53
        except:
 
54
            self.wTree = gtk.glade.XML (devel_gladefile, "main_window")
 
55
        
 
56
        dic = {
 
57
            "on_main_window_destroy" : self.quit,
 
58
            "on_quit_activate" : self.quit,
 
59
            "on_about_activate" : self.about_activate,
 
60
            "on_statistics_activate" : self.statistics_activate,
 
61
            "on_new_activate" : self.new_activate,
 
62
            "on_save_activate" : self.save_activate,
 
63
            "on_save_as_activate" : self.save_as_activate,
 
64
            "on_open_activate" : self.open_activate,
 
65
            "on_comics_treeview_row_activated" : self.comics_treeview_activated,
 
66
            "on_remove_item_activate" : self.remove_item,
 
67
            "on_add_comic_activate" : self.add_comic,
 
68
            "on_add_issue_activate" : self.add_issue,
 
69
            "on_add_multiple_issues_activate" : self.add_multiple_issues,
 
70
            "on_properties_activate" : self.properties
 
71
            }
 
72
        self.wTree.signal_autoconnect (dic)
 
73
        
 
74
        # setup treeview
 
75
        self.comicsTreeView = self.wTree.get_widget ("comics_treeview")
 
76
        self.comicsTreeModel = gtk.TreeStore (gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING)
 
77
        self.comicsTreeView.set_model (self.comicsTreeModel)
 
78
        self.comicsTreeView.set_headers_visible (True)
 
79
        self.comicsTreeView.set_search_column(COMICS_COLUMN_TITLE)
 
80
 
 
81
        renderer = gtk.CellRendererText ()
 
82
        column = gtk.TreeViewColumn ("Title/issue", renderer, markup=COMICS_COLUMN_TITLE)
 
83
        column.set_resizable (True)
 
84
        self.comicsTreeView.append_column (column)
 
85
 
 
86
        renderer = gtk.CellRendererText ()
 
87
        column = gtk.TreeViewColumn ("Publisher", renderer, text=COMICS_COLUMN_PUBLISHER)
 
88
        column.set_resizable (True)
 
89
        self.comicsTreeView.append_column (column)
 
90
 
 
91
        renderer = gtk.CellRendererText ()
 
92
        column = gtk.TreeViewColumn ("comic item id (hidden)", renderer, text=COMICS_COLUMN_COMIC_ID_HIDDEN)
 
93
        column.set_resizable (True)
 
94
 
 
95
        renderer = gtk.CellRendererText ()
 
96
        column = gtk.TreeViewColumn ("issue item id (hidden)", renderer, text=COMICS_COLUMN_ISSUE_ID_HIDDEN)
 
97
        column.set_resizable (True)
 
98
 
 
99
        self.comicsTreeView.show ()
 
100
 
 
101
        self.main_window = self.wTree.get_widget ("main_window")
 
102
        try:
 
103
            self.main_window.set_icon_from_file(window_icon_file)
 
104
        except:
 
105
            pass
 
106
        self.set_window_title()
 
107
        return
 
108
 
 
109
    def quit(self, widget):
 
110
        if (self.file_modified):
 
111
            quit_dialogwTree = None
 
112
            try:
 
113
                quit_dialogwTree = gtk.glade.XML (gladefile, "quit_dialog")
 
114
            except:
 
115
                quit_dialogwTree = gtk.glade.XML (devel_gladefile, "quit_dialog")
 
116
            quit_dialog = quit_dialogwTree.get_widget("quit_dialog")
 
117
            quit_dialog.set_transient_for(self.main_window)
 
118
            try:
 
119
                quit_dialog.set_icon_from_file(window_icon_file)
 
120
            except:
 
121
                pass
 
122
            
 
123
            result = quit_dialog.run()
 
124
 
 
125
            if (result == gtk.RESPONSE_OK):
 
126
                gtk.main_quit()
 
127
 
 
128
            quit_dialog.destroy()
 
129
        else:
 
130
            gtk.main_quit()
 
131
 
 
132
    def set_window_title(self):
 
133
        title = ""
 
134
        if (self.filename != None):
 
135
            title = os.path.basename(self.filename)
 
136
        else:
 
137
            title = "Untitled"
 
138
        if (self.file_modified):
 
139
            title = title + " (*)"
 
140
 
 
141
        title = title + " - " + program_name
 
142
            
 
143
        self.main_window.set_title(title)
 
144
        
 
145
    def fill_comics_rows(self, comics):
 
146
        self.comicsTreeModel.clear()
 
147
 
 
148
        parent_iters = {}
 
149
 
 
150
        for i,comic in enumerate(comics):
 
151
            title = comic.get_title()
 
152
            if (comic.get_volume() != "1"):
 
153
                title = title + " (Vol. " + comic.get_volume() + ")"
 
154
 
 
155
            if (comic.get_group() != "" and not parent_iters.has_key(comic.get_group())):
 
156
                tmp_iter = self.comicsTreeModel.insert_before (None, None)
 
157
 
 
158
                self.comicsTreeModel.set_value (tmp_iter, COMICS_COLUMN_TITLE, "<i>" + cgi.escape(comic.get_group()) + "</i>")
 
159
                self.comicsTreeModel.set_value (tmp_iter, COMICS_COLUMN_COMIC_ID_HIDDEN, -1)
 
160
 
 
161
                parent_iters[comic.get_group()] = tmp_iter
 
162
 
 
163
            parent_iter = None
 
164
            if (comic.get_group() != ""):
 
165
                parent_iter = parent_iters[comic.get_group()]
 
166
            iter = self.insert_comic_row (self.comicsTreeModel,
 
167
                                          parent_iter,
 
168
                                          cgi.escape(title),
 
169
                                          comic.get_publisher(),
 
170
                                          i, -1)
 
171
 
 
172
            for j,issue in enumerate(comic.get_issues()):
 
173
                issue_iter = self.insert_comic_row (self.comicsTreeModel,
 
174
                                                    iter,
 
175
                                                    cgi.escape(issue.get_issue_number()),
 
176
                                                    "",
 
177
                                                    i, j)
 
178
                
 
179
        return
 
180
 
 
181
    def insert_comic_row (self, model, parent, title, publisher, comic_id, issue_id):
 
182
        iter = model.insert_before (parent, None)
 
183
 
 
184
        model.set_value (iter, COMICS_COLUMN_TITLE, cgi.escape(title))
 
185
        model.set_value (iter, COMICS_COLUMN_PUBLISHER, publisher)
 
186
        model.set_value (iter, COMICS_COLUMN_COMIC_ID_HIDDEN, comic_id)
 
187
        model.set_value (iter, COMICS_COLUMN_ISSUE_ID_HIDDEN, issue_id)
 
188
        return iter
 
189
 
 
190
    def comics_treeview_activated (self, widget, path, column):
 
191
        iter = self.comicsTreeModel.get_iter (path)
 
192
        comic_id =  self.comicsTreeModel.get_value (iter, COMICS_COLUMN_COMIC_ID_HIDDEN)
 
193
        issue_id =  self.comicsTreeModel.get_value (iter, COMICS_COLUMN_ISSUE_ID_HIDDEN)
 
194
        if (comic_id != "-1"):
 
195
            comic = self.comics[int(comic_id)]
 
196
            if (issue_id != "-1"):
 
197
                issue = self.comics[int(comic_id)].get_issues()[int(issue_id)]
 
198
                self.show_issue_description(issue, comic)
 
199
            else:
 
200
                self.show_comic_description(comic)
 
201
        
 
202
        return
 
203
 
 
204
    def show_comic_description (self, comic):
 
205
        descriptionTextView = self.wTree.get_widget ("description_textview")
 
206
        buffer = descriptionTextView.get_buffer ()
 
207
        buffer.delete (buffer.get_start_iter (), buffer.get_end_iter ())
 
208
        iter = buffer.get_start_iter ()
 
209
        
 
210
        bold_tag = buffer.create_tag(name=None, weight=pango.WEIGHT_BOLD)
 
211
        italic_tag = buffer.create_tag(name=None, style=pango.STYLE_ITALIC)
 
212
        
 
213
        title = comic.get_title()
 
214
        if (comic.get_volume() != "1"):
 
215
            title = title + " (Vol. " + comic.get_volume() + ")"
 
216
 
 
217
        buffer.insert_with_tags(iter, title + "\n", bold_tag)
 
218
        buffer.insert(iter, str(len(comic.get_issues())) + " issues available." +  "\n\n")
 
219
        
 
220
        buffer.insert_with_tags(iter, comic.get_publisher() + "\n", italic_tag)
 
221
        buffer.insert_with_tags(iter, comic.get_type() + "\n\n", italic_tag)
 
222
        if (comic.get_comment() != ""):
 
223
            buffer.insert(iter, comic.get_comment() + "\n\n")
 
224
        return    
 
225
 
 
226
    def show_issue_description (self, issue, comic):
 
227
        descriptionTextView = self.wTree.get_widget ("description_textview")
 
228
        buffer = descriptionTextView.get_buffer ()
 
229
        buffer.delete (buffer.get_start_iter (), buffer.get_end_iter ())
 
230
        iter = buffer.get_start_iter ()
 
231
        
 
232
        bold_tag = buffer.create_tag(name=None, weight=pango.WEIGHT_BOLD)
 
233
        italic_tag = buffer.create_tag(name=None, style=pango.STYLE_ITALIC)
 
234
        
 
235
        title = comic.get_title()
 
236
        if (comic.get_volume != "1"):
 
237
            title = title + " (Vol. " + comic.get_volume() + ")"
 
238
 
 
239
        buffer.insert_with_tags(iter, title + " #" + issue.get_issue_number(), bold_tag)
 
240
        buffer.insert(iter, " " + issue.get_price() + "\n")
 
241
        buffer.insert(iter, "Condition: " + comiclist.int2condition(int(issue.get_condition())) + "\n\n")
 
242
        if (issue.get_comment() != ""):
 
243
            buffer.insert(iter, issue.get_comment() + "\n\n")
 
244
        titles = issue.get_title()
 
245
        if (len(titles) > 0):
 
246
            if (len(titles) == 1):
 
247
                buffer.insert_with_tags(iter, "Title: ", italic_tag)
 
248
            else:
 
249
                buffer.insert_with_tags(iter, "Titles: ", italic_tag)
 
250
            for i,title in enumerate(titles):
 
251
                buffer.insert(iter, title)
 
252
                if (i+1 < len(titles)):
 
253
                    buffer.insert(iter, ", ")
 
254
            buffer.insert(iter, "\n")
 
255
        writers = issue.get_writer()
 
256
        if (len(writers) > 0):
 
257
            if (len(writers) == 1):
 
258
                buffer.insert_with_tags(iter, "Writer: ", italic_tag)
 
259
            else:
 
260
                buffer.insert_with_tags(iter, "Writers: ", italic_tag)
 
261
            for i,writer in enumerate(writers):
 
262
                buffer.insert(iter, writer)
 
263
                if (i+1 < len(writers)):
 
264
                    buffer.insert(iter, ", ")
 
265
            buffer.insert(iter, "\n")
 
266
        pencillers = issue.get_penciller()
 
267
        if (len(pencillers) > 0):
 
268
            if (len(pencillers) == 1):
 
269
                buffer.insert_with_tags(iter, "Penciller: ", italic_tag)
 
270
            else:
 
271
                buffer.insert_with_tags(iter, "Pencillers: ", italic_tag)
 
272
            for i,penciller in enumerate(pencillers):
 
273
                buffer.insert(iter, penciller)
 
274
                if (i+1 < len(pencillers)):
 
275
                    buffer.insert(iter, ", ")
 
276
            buffer.insert(iter, "\n")
 
277
        inkers = issue.get_inker()
 
278
        if (len(inkers) > 0):
 
279
            if (len(inkers) == 1):
 
280
                buffer.insert_with_tags(iter, "Inker: ", italic_tag)
 
281
            else:
 
282
                buffer.insert_with_tags(iter, "Inkers: ", italic_tag)
 
283
            for i,inker in enumerate(inkers):
 
284
                buffer.insert(iter, inker)
 
285
                if (i+1 < len(inkers)):
 
286
                    buffer.insert(iter, ", ")
 
287
            buffer.insert(iter, "\n")
 
288
 
 
289
        if (issue.get_image() != ""):
 
290
            buffer.insert(iter, "\n")
 
291
            pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(issue.get_image(), 200, 200)
 
292
            buffer.insert_pixbuf(iter, pixbuf)
 
293
            buffer.insert(iter, "\n")
 
294
 
 
295
        return    
 
296
 
 
297
    def remove_item(self, widget):
 
298
        selected = self.comicsTreeView.get_selection().get_selected()
 
299
        iter = selected[1]
 
300
        if (iter != None):
 
301
            comic_id = int(selected[0].get_value(iter, COMICS_COLUMN_COMIC_ID_HIDDEN))
 
302
            issue_id = int(selected[0].get_value(iter, COMICS_COLUMN_ISSUE_ID_HIDDEN))
 
303
            if (comic_id != -1):
 
304
                comic_title = self.comics[comic_id].get_title()
 
305
                if (self.comics[comic_id].get_volume() != "1"):
 
306
                    comic_title = comic_title + " (Vol. " + self.comics[comic_id].get_volume() + ")"
 
307
                comic_publisher = self.comics[comic_id].get_publisher()
 
308
 
 
309
                are_you_sure_dialogwTree = None
 
310
                try:
 
311
                    are_you_sure_dialogwTree = gtk.glade.XML (gladefile, "are_you_sure_dialog")
 
312
                except:
 
313
                    are_you_sure_dialogwTree = gtk.glade.XML (devel_gladefile, "are_you_sure_dialog")
 
314
 
 
315
                are_you_sure_dialog = are_you_sure_dialogwTree.get_widget("are_you_sure_dialog")
 
316
                are_you_sure_dialog.set_transient_for(self.main_window)
 
317
                try:
 
318
                    are_you_sure_dialog.set_icon_from_file(window_icon_file)
 
319
                except:
 
320
                    pass
 
321
                are_you_sure_label = are_you_sure_dialogwTree.get_widget("are_you_sure_label")
 
322
                if (issue_id == -1):
 
323
                    are_you_sure_label.set_markup("Are you sure you want to remove the <i>entire</i> comic and all issues?\n\n" + "<b>" + comic_title + "</b>\n<i>" + comic_publisher + "</i>\n")
 
324
                else:
 
325
                    issue_number = self.comics[comic_id].get_issues()[issue_id].get_issue_number()
 
326
                    are_you_sure_label.set_markup("Are you sure you want to remove this issue?\n\n" + "<b>" + comic_title + " #" + issue_number + "</b>\n<i>" + comic_publisher + "</i>\n")
 
327
 
 
328
                result = are_you_sure_dialog.run()
 
329
 
 
330
                if (result == gtk.RESPONSE_OK):
 
331
                    if (issue_id == -1):
 
332
                        # remove the entire comic
 
333
                        del self.comics[comic_id]
 
334
                    else:
 
335
                        # only remove the specific issue
 
336
                        del self.comics[comic_id].get_issues()[issue_id]
 
337
                
 
338
                        self.file_modified = True
 
339
                        self.set_window_title()
 
340
 
 
341
                        self.fill_comics_rows (self.comics)
 
342
                are_you_sure_dialog.destroy()
 
343
            else:
 
344
                msg = gtk.MessageDialog(self.main_window, gtk.DIALOG_MODAL, gtk.MESSAGE_INFO, gtk.BUTTONS_OK, "You cannot remove an entire group. Please select an issue or a comic.")
 
345
                try:
 
346
                    msg.set_icon_from_file(window_icon_file)
 
347
                except:
 
348
                    pass
 
349
                result = msg.run()
 
350
                msg.destroy()
 
351
        else:
 
352
            msg = gtk.MessageDialog(self.main_window, gtk.DIALOG_MODAL, gtk.MESSAGE_INFO, gtk.BUTTONS_OK, "You must select an issue or a comic before removing.")
 
353
            try:
 
354
                msg.set_icon_from_file(window_icon_file)
 
355
            except:
 
356
                pass
 
357
            result = msg.run()
 
358
            msg.destroy()
 
359
 
 
360
    def add_comic(self, widget):
 
361
        add_comic_dialogwTree = None
 
362
        try:
 
363
            add_comic_dialogwTree = gtk.glade.XML (gladefile, "add_comic_dialog")
 
364
        except:
 
365
            add_comic_dialogwTree = gtk.glade.XML (devel_gladefile, "add_comic_dialog")
 
366
        add_comic_dialog = add_comic_dialogwTree.get_widget("add_comic_dialog")
 
367
        add_comic_dialog.set_transient_for(self.main_window)
 
368
        try:
 
369
            add_comic_dialog.set_icon_from_file(window_icon_file)
 
370
        except:
 
371
            pass
 
372
 
 
373
        publisher_arr = []
 
374
        type_arr = []
 
375
        group_arr = []
 
376
        for comic in self.comics:
 
377
            if (comic.get_publisher() != ""):
 
378
                try:
 
379
                    exists = publisher_arr.index(comic.get_publisher())
 
380
                except:
 
381
                    publisher_arr.append(comic.get_publisher())
 
382
            if (comic.get_type() != ""):
 
383
                try:
 
384
                    exists = type_arr.index(comic.get_type())
 
385
                except:
 
386
                    type_arr.append(comic.get_type())
 
387
            if (comic.get_group() != ""):
 
388
                try:
 
389
                    exists = group_arr.index(comic.get_group())
 
390
                except:
 
391
                    group_arr.append(comic.get_group())
 
392
 
 
393
        #add_comic_dialogwTree.get_widget("publisher_comboboxentry").set_property("appears-as-list", True)
 
394
        add_comic_dialogwTree.get_widget("publisher_comboboxentry").set_property("wrap-width", 2)
 
395
        add_comic_dialogwTree.get_widget("publisher_comboboxentry").remove_text(0)
 
396
 
 
397
        #add_comic_dialogwTree.get_widget("type_comboboxentry").set_property("appears-as-list", True)
 
398
        add_comic_dialogwTree.get_widget("type_comboboxentry").set_property("wrap-width", 2)
 
399
        add_comic_dialogwTree.get_widget("type_comboboxentry").remove_text(0)
 
400
 
 
401
        #add_comic_dialogwTree.get_widget("group_comboboxentry").set_property("appears-as-list", True)
 
402
        add_comic_dialogwTree.get_widget("group_comboboxentry").set_property("wrap-width", 2)
 
403
        add_comic_dialogwTree.get_widget("group_comboboxentry").remove_text(0)
 
404
 
 
405
        type_arr.sort()
 
406
        for t in type_arr:
 
407
            add_comic_dialogwTree.get_widget("type_comboboxentry").append_text(t)
 
408
 
 
409
        publisher_arr.sort()
 
410
        for p in publisher_arr:
 
411
            add_comic_dialogwTree.get_widget("publisher_comboboxentry").append_text(p)
 
412
 
 
413
        group_arr.sort()
 
414
        for g in group_arr:
 
415
            add_comic_dialogwTree.get_widget("group_comboboxentry").append_text(g)
 
416
 
 
417
            
 
418
 
 
419
        result = add_comic_dialog.run()
 
420
 
 
421
        if (result == gtk.RESPONSE_OK):
 
422
            title = add_comic_dialogwTree.get_widget("title_entry").get_text()
 
423
            publisher = add_comic_dialogwTree.get_widget("publisher_comboboxentry").get_child().get_text()
 
424
            type = add_comic_dialogwTree.get_widget("type_comboboxentry").get_child().get_text()
 
425
            add_comic_dialogwTree.get_widget("volume_spinbutton").update()
 
426
            volume = str(add_comic_dialogwTree.get_widget("volume_spinbutton").get_value_as_int())
 
427
            group = add_comic_dialogwTree.get_widget("group_comboboxentry").get_child().get_text()
 
428
            buffer = add_comic_dialogwTree.get_widget("comment_textview").get_buffer()
 
429
            comment = buffer.get_text(buffer.get_start_iter (), buffer.get_end_iter ())
 
430
 
 
431
            comic = comiclist.ComicBook()
 
432
            self.highest_uuid = str(self.uuid_gen.next())
 
433
            comic.init(title, publisher, type, volume, group, comment, "", self.highest_uuid)
 
434
            self.comics.append(comic)
 
435
            self.comics.sort(comiclist.comic_compare_title)
 
436
 
 
437
            self.file_modified = True
 
438
            self.set_window_title()
 
439
 
 
440
            self.fill_comics_rows (self.comics)
 
441
 
 
442
        add_comic_dialog.destroy()
 
443
 
 
444
    def image_browse_clicked(self, widget, entry, image):
 
445
        open_dialogwTree = None
 
446
        try:
 
447
            open_dialogwTree = gtk.glade.XML (gladefile, "open_dialog")
 
448
        except:
 
449
            open_dialogwTree = gtk.glade.XML (devel_gladefile, "open_dialog")
 
450
        open_dialog = open_dialogwTree.get_widget("open_dialog")
 
451
        open_dialog.set_transient_for(self.main_window)
 
452
        try:
 
453
            open_dialog.set_icon_from_file(window_icon_file)
 
454
        except:
 
455
            pass
 
456
 
 
457
        result = open_dialog.run()
 
458
        if (result == gtk.RESPONSE_OK):
 
459
            fname = open_dialog.get_filename()
 
460
 
 
461
            image.set_from_file(fname)
 
462
            entry.child.set_text(fname)
 
463
 
 
464
        open_dialog.destroy()
 
465
 
 
466
    def list_add_clicked(self, widget, entry, model):
 
467
        # entry can be either a comboboxentry or just a basic entry
 
468
        actual_entry = None
 
469
        try:
 
470
            actual_entry = entry.child
 
471
        except:
 
472
            actual_entry = entry
 
473
        to_add = actual_entry.get_text()
 
474
        if (to_add != ""):
 
475
            iter = model.insert_before (None, None)
 
476
            model.set_value(iter, 0, to_add)
 
477
 
 
478
    def list_remove_clicked(self, widget, treeview):
 
479
        selection = treeview.get_selection()
 
480
        model = selection.get_selected()[0]
 
481
        iter = selection.get_selected()[1]
 
482
        if (iter != None):
 
483
            model.remove(iter)
 
484
 
 
485
    def treemodel_get_list_from_model(self, model, path, iter, list):
 
486
        list.append(model.get_value(iter, 0))
 
487
        
 
488
 
 
489
    def add_issue(self, widget):
 
490
        selected = self.comicsTreeView.get_selection().get_selected()
 
491
        iter = selected[1]
 
492
        if (iter != None):
 
493
            comic_id = int(selected[0].get_value(iter, COMICS_COLUMN_COMIC_ID_HIDDEN))
 
494
            if (comic_id != -1):
 
495
                comic_title = self.comics[comic_id].get_title()
 
496
                add_issue_dialogwTree = None
 
497
                try:
 
498
                    add_issue_dialogwTree = gtk.glade.XML (gladefile, "add_issue_dialog")
 
499
                except:
 
500
                    add_issue_dialogwTree = gtk.glade.XML (devel_gladefile, "add_issue_dialog")
 
501
                add_issue_dialog = add_issue_dialogwTree.get_widget("add_issue_dialog")
 
502
                add_issue_dialogwTree.get_widget("comic_title_label").set_markup("<b>" + cgi.escape(comic_title) + "</b>")
 
503
                add_issue_dialogwTree.get_widget("condition_combobox").set_active(1)
 
504
 
 
505
                add_issue_dialogwTree.get_widget("image_browse_button").connect("clicked", self.image_browse_clicked,
 
506
                                                                                add_issue_dialogwTree.get_widget("image_comboboxentry"),
 
507
                                                                                add_issue_dialogwTree.get_widget("image"))
 
508
 
 
509
                titles_treeview = add_issue_dialogwTree.get_widget("titles_treeview")
 
510
                titles_treemodel = gtk.TreeStore (gobject.TYPE_STRING)
 
511
                titles_treeview.set_model (titles_treemodel)
 
512
                titles_treeview.set_headers_visible (False)
 
513
 
 
514
                renderer = gtk.CellRendererText ()
 
515
                column = gtk.TreeViewColumn ("Title", renderer, text=0)
 
516
                column.set_resizable (True)
 
517
                titles_treeview.append_column (column)
 
518
 
 
519
                add_issue_dialogwTree.get_widget("titles_add_button").connect("clicked", self.list_add_clicked,
 
520
                                                                              add_issue_dialogwTree.get_widget("titles_entry"),
 
521
                                                                              titles_treemodel)
 
522
                add_issue_dialogwTree.get_widget("titles_remove_button").connect("clicked", self.list_remove_clicked,
 
523
                                                                                 titles_treeview)
 
524
 
 
525
                writers_treeview = add_issue_dialogwTree.get_widget("writers_treeview")
 
526
                writers_treemodel = gtk.TreeStore (gobject.TYPE_STRING)
 
527
                writers_treeview.set_model (writers_treemodel)
 
528
                writers_treeview.set_headers_visible (False)
 
529
 
 
530
                renderer = gtk.CellRendererText ()
 
531
                column = gtk.TreeViewColumn ("Writer", renderer, text=0)
 
532
                column.set_resizable (True)
 
533
                writers_treeview.append_column (column)
 
534
 
 
535
                add_issue_dialogwTree.get_widget("writers_add_button").connect("clicked", self.list_add_clicked,
 
536
                                                                               add_issue_dialogwTree.get_widget("writers_comboboxentry"),
 
537
                                                                               writers_treemodel)
 
538
                add_issue_dialogwTree.get_widget("writers_remove_button").connect("clicked", self.list_remove_clicked,
 
539
                                                                                  writers_treeview)
 
540
 
 
541
                pencillers_treeview = add_issue_dialogwTree.get_widget("pencillers_treeview")
 
542
                pencillers_treemodel = gtk.TreeStore (gobject.TYPE_STRING)
 
543
                pencillers_treeview.set_model (pencillers_treemodel)
 
544
                pencillers_treeview.set_headers_visible (False)
 
545
 
 
546
                renderer = gtk.CellRendererText ()
 
547
                column = gtk.TreeViewColumn ("Penciller", renderer, text=0)
 
548
                column.set_resizable (True)
 
549
                pencillers_treeview.append_column (column)
 
550
 
 
551
                add_issue_dialogwTree.get_widget("pencillers_add_button").connect("clicked", self.list_add_clicked,
 
552
                                                                                  add_issue_dialogwTree.get_widget("pencillers_comboboxentry"),
 
553
                                                                                  pencillers_treemodel)
 
554
                add_issue_dialogwTree.get_widget("pencillers_remove_button").connect("clicked", self.list_remove_clicked,
 
555
                                                                                     pencillers_treeview)
 
556
 
 
557
                inkers_treeview = add_issue_dialogwTree.get_widget("inkers_treeview")
 
558
                inkers_treemodel = gtk.TreeStore (gobject.TYPE_STRING)
 
559
                inkers_treeview.set_model (inkers_treemodel)
 
560
                inkers_treeview.set_headers_visible (False)
 
561
 
 
562
                renderer = gtk.CellRendererText ()
 
563
                column = gtk.TreeViewColumn ("Inker", renderer, text=0)
 
564
                column.set_resizable (True)
 
565
                inkers_treeview.append_column (column)
 
566
 
 
567
                add_issue_dialogwTree.get_widget("inkers_add_button").connect("clicked", self.list_add_clicked,
 
568
                                                                              add_issue_dialogwTree.get_widget("inkers_comboboxentry"),
 
569
                                                                              inkers_treemodel)
 
570
                add_issue_dialogwTree.get_widget("inkers_remove_button").connect("clicked", self.list_remove_clicked,
 
571
                                                                                 inkers_treeview)
 
572
                add_issue_dialog.set_transient_for(self.main_window)
 
573
                try:
 
574
                    add_issue_dialog.set_icon_from_file(window_icon_file)
 
575
                except:
 
576
                    pass
 
577
 
 
578
 
 
579
 
 
580
 
 
581
                #add_issue_dialogwTree.get_widget("cover_price_comboboxentry").set_property("appears-as-list", True)
 
582
                add_issue_dialogwTree.get_widget("cover_price_comboboxentry").set_property("wrap-width", 2)
 
583
                add_issue_dialogwTree.get_widget("cover_price_comboboxentry").remove_text(0)
 
584
                #add_issue_dialogwTree.get_widget("current_price_comboboxentry").set_property("appears-as-list", True)
 
585
                add_issue_dialogwTree.get_widget("current_price_comboboxentry").set_property("wrap-width", 2)
 
586
                add_issue_dialogwTree.get_widget("current_price_comboboxentry").remove_text(0)
 
587
                #add_issue_dialogwTree.get_widget("purchase_price_comboboxentry").set_property("appears-as-list", True)
 
588
                add_issue_dialogwTree.get_widget("purchase_price_comboboxentry").set_property("wrap-width", 2)
 
589
                add_issue_dialogwTree.get_widget("purchase_price_comboboxentry").remove_text(0)
 
590
                #add_issue_dialogwTree.get_widget("location_comboboxentry").set_property("appears-as-list", True)
 
591
                add_issue_dialogwTree.get_widget("location_comboboxentry").set_property("wrap-width", 2)
 
592
                add_issue_dialogwTree.get_widget("location_comboboxentry").remove_text(0)
 
593
                #add_issue_dialogwTree.get_widget("writers_comboboxentry").set_property("appears-as-list", True)
 
594
                add_issue_dialogwTree.get_widget("writers_comboboxentry").set_property("wrap-width", 2)
 
595
                add_issue_dialogwTree.get_widget("writers_comboboxentry").remove_text(0)
 
596
                #add_issue_dialogwTree.get_widget("pencillers_comboboxentry").set_property("appears-as-list", True)
 
597
                add_issue_dialogwTree.get_widget("pencillers_comboboxentry").set_property("wrap-width", 2)
 
598
                add_issue_dialogwTree.get_widget("pencillers_comboboxentry").remove_text(0)
 
599
                #add_issue_dialogwTree.get_widget("inkers_comboboxentry").set_property("appears-as-list", True)
 
600
                add_issue_dialogwTree.get_widget("inkers_comboboxentry").set_property("wrap-width", 2)
 
601
                add_issue_dialogwTree.get_widget("inkers_comboboxentry").remove_text(0)
 
602
 
 
603
                cover_price_arr = []
 
604
                current_price_arr = []
 
605
                purchase_price_arr = []
 
606
                location_arr = []
 
607
                pencillers_arr = []
 
608
                writers_arr = []
 
609
                inkers_arr = []
 
610
                for comic in self.comics:
 
611
                    for issue in comic.get_issues():
 
612
                        if (issue.get_cover_price() != ""):
 
613
                            try:
 
614
                                exists = cover_price_arr.index(issue.get_cover_price())
 
615
                            except:
 
616
                                cover_price_arr.append(issue.get_cover_price())
 
617
                        if (issue.get_current_price() != ""):
 
618
                            try:
 
619
                                exists = current_price_arr.index(issue.get_current_price())
 
620
                            except:
 
621
                                current_price_arr.append(issue.get_current_price())
 
622
                        if (issue.get_purchase_price() != ""):
 
623
                            try:
 
624
                                exists = purchase_price_arr.index(issue.get_purchase_price())
 
625
                            except:
 
626
                                purchase_price_arr.append(issue.get_purchase_price())
 
627
                        if (issue.get_location() != ""):
 
628
                            try:
 
629
                                exists = location_arr.index(issue.get_location())
 
630
                            except:
 
631
                                location_arr.append(issue.get_location())
 
632
                        for p in issue.get_penciller():
 
633
                            try:
 
634
                                exists = pencillers_arr.index(p)
 
635
                            except:
 
636
                                pencillers_arr.append(p)
 
637
                        for p in issue.get_writer():
 
638
                            try:
 
639
                                exists = writers_arr.index(p)
 
640
                            except:
 
641
                                writers_arr.append(p)
 
642
                        for p in issue.get_inker():
 
643
                            try:
 
644
                                exists = inkers_arr.index(p)
 
645
                            except:
 
646
                                inkers_arr.append(p)
 
647
 
 
648
                cover_price_arr.sort()
 
649
                for g in cover_price_arr:
 
650
                    add_issue_dialogwTree.get_widget("cover_price_comboboxentry").append_text(g)
 
651
                current_price_arr.sort()
 
652
                for g in current_price_arr:
 
653
                    add_issue_dialogwTree.get_widget("current_price_comboboxentry").append_text(g)
 
654
                purchase_price_arr.sort()
 
655
                for g in purchase_price_arr:
 
656
                    add_issue_dialogwTree.get_widget("purchase_price_comboboxentry").append_text(g)
 
657
                location_arr.sort()
 
658
                for g in location_arr:
 
659
                    add_issue_dialogwTree.get_widget("location_comboboxentry").append_text(g)
 
660
                pencillers_arr.sort()
 
661
                for g in pencillers_arr:
 
662
                    add_issue_dialogwTree.get_widget("pencillers_comboboxentry").append_text(g)
 
663
                writers_arr.sort()
 
664
                for g in writers_arr:
 
665
                    add_issue_dialogwTree.get_widget("writers_comboboxentry").append_text(g)
 
666
                inkers_arr.sort()
 
667
                for g in inkers_arr:
 
668
                    add_issue_dialogwTree.get_widget("inkers_comboboxentry").append_text(g)
 
669
 
 
670
 
 
671
 
 
672
 
 
673
 
 
674
                if (len(self.comics[comic_id].get_issues()) >= 1):
 
675
                    latest_iss = self.comics[comic_id].get_issues()[len(self.comics[comic_id].get_issues())-1]
 
676
                    try:
 
677
                        i = int(latest_iss.get_issue_number()) + 1
 
678
                        add_issue_dialogwTree.get_widget("issue_number_entry").set_text(str(i))
 
679
                    except:
 
680
                        pass
 
681
                    add_issue_dialogwTree.get_widget("cover_price_comboboxentry").child.set_text(latest_iss.get_price())
 
682
                    for writer in latest_iss.get_writer():
 
683
                        if (writer != ""):
 
684
                            iter = writers_treemodel.insert_before (None, None)
 
685
                            writers_treemodel.set_value(iter, 0, writer)
 
686
                    for penciller in latest_iss.get_penciller():
 
687
                        if (penciller != ""):
 
688
                            iter = pencillers_treemodel.insert_before (None, None)
 
689
                            pencillers_treemodel.set_value(iter, 0, penciller)
 
690
                    for inker in latest_iss.get_inker():
 
691
                        if (inker != ""):
 
692
                            iter = inkers_treemodel.insert_before (None, None)
 
693
                            inkers_treemodel.set_value(iter, 0, inker)
 
694
                
 
695
 
 
696
                result = add_issue_dialog.run()
 
697
 
 
698
                if (result == gtk.RESPONSE_OK):
 
699
                    issue_number = add_issue_dialogwTree.get_widget("issue_number_entry").get_text()
 
700
                    condition = str(add_issue_dialogwTree.get_widget("condition_combobox").get_active())
 
701
                    cover_price = add_issue_dialogwTree.get_widget("cover_price_comboboxentry").child.get_text()
 
702
                    purchase_price = add_issue_dialogwTree.get_widget("purchase_price_comboboxentry").child.get_text()
 
703
                    current_price = add_issue_dialogwTree.get_widget("current_price_comboboxentry").child.get_text()
 
704
 
 
705
                    location = add_issue_dialogwTree.get_widget("location_comboboxentry").child.get_text()
 
706
 
 
707
                    image = add_issue_dialogwTree.get_widget("image_comboboxentry").child.get_text()
 
708
 
 
709
                    comment_buffer = add_issue_dialogwTree.get_widget("comment_textview").get_buffer()
 
710
                    comment = comment_buffer.get_text(comment_buffer.get_start_iter(), comment_buffer.get_end_iter())
 
711
 
 
712
                    date = str(add_issue_dialogwTree.get_widget("date_dateedit").get_time())
 
713
 
 
714
                    issue = comiclist.Issue()
 
715
                    issue.set_issue_number(issue_number)
 
716
                    issue.set_condition(condition)
 
717
 
 
718
                    issue.set_price(cover_price)
 
719
                    issue.set_purchase_price(purchase_price)
 
720
                    issue.set_current_price(current_price)
 
721
 
 
722
                    issue.set_location(location)
 
723
 
 
724
                    issue.set_image(image)
 
725
 
 
726
                    issue.set_comment(comment)
 
727
 
 
728
                    issue.set_date(date)
 
729
 
 
730
                    titles = []
 
731
                    titles_treemodel.foreach(self.treemodel_get_list_from_model, titles)
 
732
                    issue.set_title(titles)
 
733
 
 
734
                    writers = []
 
735
                    writers_treemodel.foreach(self.treemodel_get_list_from_model, writers)
 
736
                    issue.set_writer(writers)
 
737
 
 
738
                    pencillers = []
 
739
                    pencillers_treemodel.foreach(self.treemodel_get_list_from_model, pencillers)
 
740
                    issue.set_penciller(pencillers)
 
741
 
 
742
                    inkers = []
 
743
                    inkers_treemodel.foreach(self.treemodel_get_list_from_model, inkers)
 
744
                    issue.set_inker(inkers)
 
745
 
 
746
                    self.highest_uuid = str(self.uuid_gen.next())
 
747
                    issue.set_guid(self.highest_uuid)
 
748
                    
 
749
                    self.comics[comic_id].append_issue(issue)
 
750
 
 
751
                    self.comics[comic_id].get_issues().sort(comiclist.issue_compare_issue_number)
 
752
                    self.fill_comics_rows (self.comics)
 
753
 
 
754
                    self.file_modified = True
 
755
                    self.set_window_title()
 
756
 
 
757
                add_issue_dialog.destroy()
 
758
            else:
 
759
                msg = gtk.MessageDialog(self.main_window, gtk.DIALOG_MODAL, gtk.MESSAGE_INFO, gtk.BUTTONS_OK, "You cannot select a group to add issues to. Please select a comic instead.")
 
760
                try:
 
761
                    msg.set_icon_from_file(window_icon_file)
 
762
                except:
 
763
                    pass
 
764
                result = msg.run()
 
765
                msg.destroy()
 
766
        else:
 
767
            msg = gtk.MessageDialog(self.main_window, gtk.DIALOG_MODAL, gtk.MESSAGE_INFO, gtk.BUTTONS_OK, "You must select a comic before adding issues.")
 
768
            try:
 
769
                msg.set_icon_from_file(window_icon_file)
 
770
            except:
 
771
                pass
 
772
            result = msg.run()
 
773
            msg.destroy()
 
774
            
 
775
 
 
776
    def add_multiple_issues(self, widget):
 
777
        selected = self.comicsTreeView.get_selection().get_selected()
 
778
        iter = selected[1]
 
779
        if (iter != None):
 
780
            comic_id = int(selected[0].get_value(iter, COMICS_COLUMN_COMIC_ID_HIDDEN))
 
781
            if (comic_id != -1):
 
782
                comic_title = self.comics[comic_id].get_title()
 
783
                add_multiple_issues_dialogwTree = None
 
784
                try:
 
785
                    add_multiple_issues_dialogwTree = gtk.glade.XML (gladefile, "add_multiple_issues_dialog")
 
786
                except:
 
787
                    add_multiple_issues_dialogwTree = gtk.glade.XML (devel_gladefile, "add_multiple_issues_dialog")
 
788
                add_multiple_issues_dialog = add_multiple_issues_dialogwTree.get_widget("add_multiple_issues_dialog")
 
789
                add_multiple_issues_dialogwTree.get_widget("comic_title_label").set_markup("<b>" + cgi.escape(comic_title) + "</b>")
 
790
 
 
791
                add_multiple_issues_dialog.set_transient_for(self.main_window)
 
792
                try:
 
793
                    add_multiple_issues_dialog.set_icon_from_file(window_icon_file)
 
794
                except:
 
795
                    pass
 
796
 
 
797
                result = add_multiple_issues_dialog.run()
 
798
 
 
799
                if (result == gtk.RESPONSE_OK):
 
800
                    add_multiple_issues_dialogwTree.get_widget("from_issue_spinbutton").update()
 
801
                    add_multiple_issues_dialogwTree.get_widget("to_issue_spinbutton").update()
 
802
                    from_issue = add_multiple_issues_dialogwTree.get_widget("from_issue_spinbutton").get_value_as_int()
 
803
                    to_issue = add_multiple_issues_dialogwTree.get_widget("to_issue_spinbutton").get_value_as_int()
 
804
 
 
805
                    for i in range(from_issue, to_issue + 1):
 
806
                        issue = comiclist.Issue()
 
807
                        issue.set_issue_number(str(i))
 
808
                        self.highest_uuid = str(self.uuid_gen.next())
 
809
                        issue.set_guid(self.highest_uuid)
 
810
                        
 
811
                        self.comics[comic_id].append_issue(issue)
 
812
 
 
813
                    self.comics[comic_id].get_issues().sort(comiclist.issue_compare_issue_number)
 
814
                    self.fill_comics_rows (self.comics)
 
815
 
 
816
                    self.file_modified = True
 
817
                    self.set_window_title()
 
818
 
 
819
                add_multiple_issues_dialog.destroy()
 
820
            else:
 
821
                msg = gtk.MessageDialog(self.main_window, gtk.DIALOG_MODAL, gtk.MESSAGE_INFO, gtk.BUTTONS_OK, "You cannot select a group to add issues to. Please select a comic instead.")
 
822
                try:
 
823
                    msg.set_icon_from_file(window_icon_file)
 
824
                except:
 
825
                    pass
 
826
                result = msg.run()
 
827
                msg.destroy()
 
828
        else:
 
829
            msg = gtk.MessageDialog(self.main_window, gtk.DIALOG_MODAL, gtk.MESSAGE_INFO, gtk.BUTTONS_OK, "You must select a comic before adding issues.")
 
830
            try:
 
831
                msg.set_icon_from_file(window_icon_file)
 
832
            except:
 
833
                pass
 
834
            result = msg.run()
 
835
            msg.destroy()
 
836
 
 
837
    def properties(self, widget):
 
838
        selected = self.comicsTreeView.get_selection().get_selected()
 
839
        iter = selected[1]
 
840
        if (iter != None):
 
841
            comic_id =  self.comicsTreeModel.get_value (iter, COMICS_COLUMN_COMIC_ID_HIDDEN)
 
842
            issue_id =  self.comicsTreeModel.get_value (iter, COMICS_COLUMN_ISSUE_ID_HIDDEN)
 
843
            if (comic_id != "-1"):
 
844
                comic = self.comics[int(comic_id)]
 
845
                if (issue_id != "-1"):
 
846
                    issue = self.comics[int(comic_id)].get_issues()[int(issue_id)]
 
847
 
 
848
                    # TODO: "merge" this method with add_issue and add_comic
 
849
 
 
850
                    add_issue_dialogwTree = None
 
851
                    try:
 
852
                        add_issue_dialogwTree = gtk.glade.XML (gladefile, "add_issue_dialog")
 
853
                    except:
 
854
                        add_issue_dialogwTree = gtk.glade.XML (devel_gladefile, "add_issue_dialog")
 
855
                    add_issue_dialog = add_issue_dialogwTree.get_widget("add_issue_dialog")
 
856
                    add_issue_dialogwTree.get_widget("comic_title_label").set_markup("<b>" + cgi.escape(comic.get_title()) + "</b>")
 
857
                    add_issue_dialogwTree.get_widget("adding_to_label").set_text("Editing issue from:")
 
858
 
 
859
                    add_issue_dialogwTree.get_widget("issue_number_entry").set_text(issue.get_issue_number())
 
860
                    add_issue_dialogwTree.get_widget("condition_combobox").set_active(int(issue.get_condition()))
 
861
                    add_issue_dialogwTree.get_widget("cover_price_comboboxentry").child.set_text(issue.get_price())
 
862
                    add_issue_dialogwTree.get_widget("purchase_price_comboboxentry").child.set_text(issue.get_purchase_price())
 
863
                    add_issue_dialogwTree.get_widget("current_price_comboboxentry").child.set_text(issue.get_current_price())
 
864
                    
 
865
                    add_issue_dialogwTree.get_widget("location_comboboxentry").child.set_text(issue.get_location())
 
866
                    
 
867
                    add_issue_dialogwTree.get_widget("image_comboboxentry").child.set_text(issue.get_image())
 
868
                    if (issue.get_image() != ""):
 
869
                        add_issue_dialogwTree.get_widget("image").set_from_file(issue.get_image())
 
870
                    
 
871
                    comment_buffer = add_issue_dialogwTree.get_widget("comment_textview").get_buffer()
 
872
                    comment_buffer.set_text(issue.get_comment())
 
873
                    
 
874
                    add_issue_dialogwTree.get_widget("date_dateedit").set_time(int(issue.get_date()))
 
875
 
 
876
 
 
877
 
 
878
                    add_issue_dialogwTree.get_widget("image_browse_button").connect("clicked", self.image_browse_clicked,
 
879
                                                                                    add_issue_dialogwTree.get_widget("image_comboboxentry"),
 
880
                                                                                    add_issue_dialogwTree.get_widget("image"))
 
881
 
 
882
                    titles_treeview = add_issue_dialogwTree.get_widget("titles_treeview")
 
883
                    titles_treemodel = gtk.TreeStore (gobject.TYPE_STRING)
 
884
                    titles_treeview.set_model (titles_treemodel)
 
885
                    titles_treeview.set_headers_visible (False)
 
886
 
 
887
                    renderer = gtk.CellRendererText ()
 
888
                    column = gtk.TreeViewColumn ("Title", renderer, text=0)
 
889
                    column.set_resizable (True)
 
890
                    titles_treeview.append_column (column)
 
891
 
 
892
                    add_issue_dialogwTree.get_widget("titles_add_button").connect("clicked", self.list_add_clicked,
 
893
                                                                                  add_issue_dialogwTree.get_widget("titles_entry"),
 
894
                                                                                  titles_treemodel)
 
895
                    add_issue_dialogwTree.get_widget("titles_remove_button").connect("clicked", self.list_remove_clicked,
 
896
                                                                                     titles_treeview)
 
897
 
 
898
                    writers_treeview = add_issue_dialogwTree.get_widget("writers_treeview")
 
899
                    writers_treemodel = gtk.TreeStore (gobject.TYPE_STRING)
 
900
                    writers_treeview.set_model (writers_treemodel)
 
901
                    writers_treeview.set_headers_visible (False)
 
902
 
 
903
                    renderer = gtk.CellRendererText ()
 
904
                    column = gtk.TreeViewColumn ("Writer", renderer, text=0)
 
905
                    column.set_resizable (True)
 
906
                    writers_treeview.append_column (column)
 
907
 
 
908
                    add_issue_dialogwTree.get_widget("writers_add_button").connect("clicked", self.list_add_clicked,
 
909
                                                                                   add_issue_dialogwTree.get_widget("writers_comboboxentry"),
 
910
                                                                                   writers_treemodel)
 
911
                    add_issue_dialogwTree.get_widget("writers_remove_button").connect("clicked", self.list_remove_clicked,
 
912
                                                                                      writers_treeview)
 
913
 
 
914
                    pencillers_treeview = add_issue_dialogwTree.get_widget("pencillers_treeview")
 
915
                    pencillers_treemodel = gtk.TreeStore (gobject.TYPE_STRING)
 
916
                    pencillers_treeview.set_model (pencillers_treemodel)
 
917
                    pencillers_treeview.set_headers_visible (False)
 
918
 
 
919
                    renderer = gtk.CellRendererText ()
 
920
                    column = gtk.TreeViewColumn ("Penciller", renderer, text=0)
 
921
                    column.set_resizable (True)
 
922
                    pencillers_treeview.append_column (column)
 
923
 
 
924
                    add_issue_dialogwTree.get_widget("pencillers_add_button").connect("clicked", self.list_add_clicked,
 
925
                                                                                      add_issue_dialogwTree.get_widget("pencillers_comboboxentry"),
 
926
                                                                                      pencillers_treemodel)
 
927
                    add_issue_dialogwTree.get_widget("pencillers_remove_button").connect("clicked", self.list_remove_clicked,
 
928
                                                                                         pencillers_treeview)
 
929
 
 
930
                    inkers_treeview = add_issue_dialogwTree.get_widget("inkers_treeview")
 
931
                    inkers_treemodel = gtk.TreeStore (gobject.TYPE_STRING)
 
932
                    inkers_treeview.set_model (inkers_treemodel)
 
933
                    inkers_treeview.set_headers_visible (False)
 
934
 
 
935
                    renderer = gtk.CellRendererText ()
 
936
                    column = gtk.TreeViewColumn ("Inker", renderer, text=0)
 
937
                    column.set_resizable (True)
 
938
                    inkers_treeview.append_column (column)
 
939
 
 
940
                    add_issue_dialogwTree.get_widget("inkers_add_button").connect("clicked", self.list_add_clicked,
 
941
                                                                                  add_issue_dialogwTree.get_widget("inkers_comboboxentry"),
 
942
                                                                                  inkers_treemodel)
 
943
                    add_issue_dialogwTree.get_widget("inkers_remove_button").connect("clicked", self.list_remove_clicked,
 
944
                                                                                     inkers_treeview)
 
945
                    add_issue_dialog.set_transient_for(self.main_window)
 
946
                    try:
 
947
                        add_issue_dialog.set_icon_from_file(window_icon_file)
 
948
                    except:
 
949
                        pass
 
950
                    add_issue_dialog.set_title("Edit Issue")
 
951
 
 
952
                    for t in issue.get_title():
 
953
                        if (t != ""):
 
954
                            iter = titles_treemodel.insert_before (None, None)
 
955
                            titles_treemodel.set_value(iter, 0, t)
 
956
 
 
957
                    for w in issue.get_writer():
 
958
                        if (w != ""):
 
959
                            iter = writers_treemodel.insert_before (None, None)
 
960
                            writers_treemodel.set_value(iter, 0, w)
 
961
 
 
962
                    for p in issue.get_penciller():
 
963
                        if (p != ""):
 
964
                            iter = pencillers_treemodel.insert_before (None, None)
 
965
                            pencillers_treemodel.set_value(iter, 0, p)
 
966
 
 
967
                    for i in issue.get_inker():
 
968
                        if (i != ""):
 
969
                            iter = inkers_treemodel.insert_before (None, None)
 
970
                            inkers_treemodel.set_value(iter, 0, i)
 
971
 
 
972
 
 
973
                    result = add_issue_dialog.run()
 
974
 
 
975
                    if (result == gtk.RESPONSE_OK):
 
976
                        issue_number = add_issue_dialogwTree.get_widget("issue_number_entry").get_text()
 
977
                        condition = str(add_issue_dialogwTree.get_widget("condition_combobox").get_active())
 
978
                        cover_price = add_issue_dialogwTree.get_widget("cover_price_comboboxentry").child.get_text()
 
979
                        purchase_price = add_issue_dialogwTree.get_widget("purchase_price_comboboxentry").child.get_text()
 
980
                        current_price = add_issue_dialogwTree.get_widget("current_price_comboboxentry").child.get_text()
 
981
 
 
982
                        location = add_issue_dialogwTree.get_widget("location_comboboxentry").child.get_text()
 
983
 
 
984
                        image = add_issue_dialogwTree.get_widget("image_comboboxentry").child.get_text()
 
985
 
 
986
                        comment_buffer = add_issue_dialogwTree.get_widget("comment_textview").get_buffer()
 
987
                        comment = comment_buffer.get_text(comment_buffer.get_start_iter(), comment_buffer.get_end_iter())
 
988
 
 
989
                        date = str(add_issue_dialogwTree.get_widget("date_dateedit").get_time())
 
990
 
 
991
                        issue.set_issue_number(issue_number)
 
992
                        issue.set_condition(condition)
 
993
 
 
994
                        issue.set_price(cover_price)
 
995
                        issue.set_purchase_price(purchase_price)
 
996
                        issue.set_current_price(current_price)
 
997
 
 
998
                        issue.set_location(location)
 
999
 
 
1000
                        issue.set_image(image)
 
1001
 
 
1002
                        issue.set_comment(comment)
 
1003
 
 
1004
                        issue.set_date(date)
 
1005
 
 
1006
                        titles = []
 
1007
                        titles_treemodel.foreach(self.treemodel_get_list_from_model, titles)
 
1008
                        issue.set_title(titles)
 
1009
 
 
1010
                        writers = []
 
1011
                        writers_treemodel.foreach(self.treemodel_get_list_from_model, writers)
 
1012
                        issue.set_writer(writers)
 
1013
 
 
1014
                        pencillers = []
 
1015
                        pencillers_treemodel.foreach(self.treemodel_get_list_from_model, pencillers)
 
1016
                        issue.set_penciller(pencillers)
 
1017
 
 
1018
                        inkers = []
 
1019
                        inkers_treemodel.foreach(self.treemodel_get_list_from_model, inkers)
 
1020
                        issue.set_inker(inkers)
 
1021
 
 
1022
                        self.comics[int(comic_id)].get_issues().sort(comiclist.issue_compare_issue_number)
 
1023
                        self.fill_comics_rows (self.comics)
 
1024
 
 
1025
                        self.file_modified = True
 
1026
                        self.set_window_title()
 
1027
 
 
1028
                    add_issue_dialog.destroy()
 
1029
 
 
1030
                else:
 
1031
                    add_comic_dialogwTree = None
 
1032
                    try:
 
1033
                        add_comic_dialogwTree = gtk.glade.XML (gladefile, "add_comic_dialog")
 
1034
                    except:
 
1035
                        add_comic_dialogwTree = gtk.glade.XML (devel_gladefile, "add_comic_dialog")
 
1036
                    add_comic_dialog = add_comic_dialogwTree.get_widget("add_comic_dialog")
 
1037
                    add_comic_dialog.set_transient_for(self.main_window)
 
1038
                    try:
 
1039
                        add_comic_dialog.set_icon_from_file(window_icon_file)
 
1040
                    except:
 
1041
                        pass
 
1042
                    add_comic_dialog.set_title("Edit Comic")
 
1043
 
 
1044
                    add_comic_dialogwTree.get_widget("title_entry").set_text(comic.get_title())
 
1045
                    add_comic_dialogwTree.get_widget("publisher_comboboxentry").get_child().set_text(comic.get_publisher())
 
1046
                    add_comic_dialogwTree.get_widget("type_comboboxentry").get_child().set_text(comic.get_type())
 
1047
                    add_comic_dialogwTree.get_widget("volume_spinbutton").set_value(int(comic.get_volume()))
 
1048
                    add_comic_dialogwTree.get_widget("group_comboboxentry").get_child().set_text(comic.get_group())
 
1049
                    buffer = add_comic_dialogwTree.get_widget("comment_textview").get_buffer()
 
1050
                    buffer.set_text(comic.get_comment())
 
1051
 
 
1052
                    result = add_comic_dialog.run()
 
1053
 
 
1054
                    if (result == gtk.RESPONSE_OK):
 
1055
                        comic.set_title(add_comic_dialogwTree.get_widget("title_entry").get_text())
 
1056
                        comic.set_publisher(add_comic_dialogwTree.get_widget("publisher_comboboxentry").get_child().get_text())
 
1057
                        comic.set_type(add_comic_dialogwTree.get_widget("type_comboboxentry").get_child().get_text())
 
1058
                        add_comic_dialogwTree.get_widget("volume_spinbutton").update()
 
1059
                        comic.set_volume(str(add_comic_dialogwTree.get_widget("volume_spinbutton").get_value_as_int()))
 
1060
                        comic.set_group(add_comic_dialogwTree.get_widget("group_comboboxentry").get_child().get_text())
 
1061
                        buffer = add_comic_dialogwTree.get_widget("comment_textview").get_buffer()
 
1062
                        comic.set_comment(buffer.get_text(buffer.get_start_iter (), buffer.get_end_iter ()))
 
1063
 
 
1064
                        self.comics.sort(comiclist.comic_compare_title)
 
1065
 
 
1066
                        self.file_modified = True
 
1067
                        self.set_window_title()
 
1068
 
 
1069
                        self.fill_comics_rows (self.comics)
 
1070
 
 
1071
                    add_comic_dialog.destroy()
 
1072
 
 
1073
    def statistics_activate(self, widget):
 
1074
        num_issues = 0
 
1075
 
 
1076
        num_with_cover_price = 0
 
1077
        float_cover_price = 0.0
 
1078
        invalid_cover_prices = 0
 
1079
 
 
1080
        mint_issues = 0
 
1081
        near_mint_issues = 0
 
1082
        
 
1083
        for c in self.comics:
 
1084
            for i in c.get_issues():
 
1085
                num_issues = num_issues + 1
 
1086
                if (i.get_price() != ""):
 
1087
                    num_with_cover_price = num_with_cover_price + 1
 
1088
                    try:
 
1089
                        float_cover_price = float_cover_price + float(string.replace(i.get_price(), "$", ""))
 
1090
                    except:
 
1091
                        invalid_cover_prices = invalid_cover_prices + 1
 
1092
                        print c.get_title() + " #" + i.get_issue_number()
 
1093
                        print "Invalid price: " + i.get_price()
 
1094
 
 
1095
                if (i.get_condition() == "0"):
 
1096
                    mint_issues = mint_issues + 1
 
1097
                if (i.get_condition() == "1"):
 
1098
                    near_mint_issues = near_mint_issues + 1
 
1099
                    
 
1100
        basic_info = str(len(self.comics)) + " comic titles.\n"
 
1101
        basic_info = basic_info + str(num_issues) + " issues."
 
1102
 
 
1103
        cover_price = str(num_with_cover_price) + " issues has a cover price.\n"
 
1104
        cover_price = cover_price + str(invalid_cover_prices) + " issues has an invalid cover price.\n"
 
1105
        cover_price = cover_price + "Total value based on cover price: $" + str(float_cover_price) + ".\n"
 
1106
        if (num_issues > 0):
 
1107
            cover_price = cover_price + "Average price per issue based on cover price: $" + str(round(float_cover_price/num_issues, 2)) + "."
 
1108
 
 
1109
        stats_dialogwTree = None
 
1110
        try:
 
1111
            stats_dialogwTree = gtk.glade.XML (gladefile, "stats_dialog")
 
1112
        except:
 
1113
            stats_dialogwTree = gtk.glade.XML (devel_gladefile, "stats_dialog")
 
1114
        stats_dialog = stats_dialogwTree.get_widget("stats_dialog")
 
1115
        stats_dialogwTree.get_widget("basic_info_label").set_text(basic_info)
 
1116
        stats_dialogwTree.get_widget("cover_price_label").set_text(cover_price)
 
1117
 
 
1118
        stats_dialog.set_transient_for(self.main_window)
 
1119
        try:
 
1120
            stats_dialog.set_icon_from_file(window_icon_file)
 
1121
        except:
 
1122
            pass
 
1123
 
 
1124
        stats_dialog.run()
 
1125
        stats_dialog.destroy()
 
1126
        
 
1127
        num_with_purchase_price = 0
 
1128
        float_purchase_price = 0.0
 
1129
        invalid_purchase_prices = 0
 
1130
        for c in self.comics:
 
1131
            for i in c.get_issues():
 
1132
                if (i.get_purchase_price() != ""):
 
1133
                    num_with_purchase_price = num_with_purchase_price + 1
 
1134
                    try:
 
1135
                        float_purchase_price = float_purchase_price + float(string.replace(i.get_purchase_price(), "$", ""))
 
1136
                    except:
 
1137
                        invalid_purchase_prices = invalid_purchase_prices + 1
 
1138
        print str(num_with_purchase_price) + " issues has a purchase price"
 
1139
        print str(invalid_purchase_prices) + " issues has an invalid purchase price"
 
1140
        print "Total value based on purchase price: $" + str(float_purchase_price)
 
1141
 
 
1142
        num_with_current_price = 0
 
1143
        float_current_price = 0.0
 
1144
        invalid_current_prices = 0
 
1145
        for c in self.comics:
 
1146
            for i in c.get_issues():
 
1147
                if (i.get_current_price() != ""):
 
1148
                    num_with_current_price = num_with_current_price + 1
 
1149
                    try:
 
1150
                        float_current_price = float_current_price + float(string.replace(i.get_current_price(), "$", ""))
 
1151
                    except:
 
1152
                        invalid_current_prices = invalid_current_prices + 1
 
1153
        print str(num_with_current_price) + " issues has a current price"
 
1154
        print str(invalid_current_prices) + " issues has an invalid current price"
 
1155
        print "Total value based on current price: $" + str(float_current_price)
 
1156
 
 
1157
        print str(mint_issues) + " issues are in mint condition"
 
1158
        print str(near_mint_issues) + " issues are in near mint condition"
 
1159
 
 
1160
    def about_activate(self, widget):
 
1161
        about_dialogwTree = None
 
1162
        try:
 
1163
            about_dialogwTree = gtk.glade.XML (gladefile, "about")
 
1164
        except:
 
1165
            about_dialogwTree = gtk.glade.XML (devel_gladefile, "about")
 
1166
        about_dialog = about_dialogwTree.get_widget("about")
 
1167
        about_dialog.set_property('name', program_name)
 
1168
        about_dialog.set_property('version', program_version)
 
1169
        try:
 
1170
            about_dialog.set_icon_from_file(window_icon_file)
 
1171
        except:
 
1172
            pass
 
1173
 
 
1174
    def new_activate(self, widget):
 
1175
        self.comics = []
 
1176
        self.filename = None
 
1177
        self.comicsTreeModel.clear()
 
1178
        self.file_modified = False
 
1179
        self.set_window_title()
 
1180
        
 
1181
    def save_activate(self, widget):
 
1182
        if (self.filename != None):
 
1183
            fileops.save_gco(self.filename, self.comics, self.highest_uuid)
 
1184
        else:
 
1185
            self.save_as_activate(widget)
 
1186
 
 
1187
    def save_as_activate(self, widget):
 
1188
        save_dialogwTree = None
 
1189
        try:
 
1190
            save_dialogwTree = gtk.glade.XML (gladefile, "save_dialog")
 
1191
        except:
 
1192
            save_dialogwTree = gtk.glade.XML (devel_gladefile, "save_dialog")
 
1193
        save_dialog = save_dialogwTree.get_widget("save_dialog")
 
1194
        save_dialog.set_transient_for(self.main_window)
 
1195
        try:
 
1196
            save_dialog.set_icon_from_file(window_icon_file)
 
1197
        except:
 
1198
            pass
 
1199
 
 
1200
        result = save_dialog.run()
 
1201
        if (result == gtk.RESPONSE_OK):
 
1202
            temp = save_dialog.get_filename()
 
1203
 
 
1204
            if (temp != ""):
 
1205
                # TODO: Check that the file doesn't already exist. If it does display a warning.
 
1206
                self.filename = temp
 
1207
                self.file_modified = False
 
1208
                self.set_window_title()
 
1209
                fileops.save_gco(self.filename, self.comics, self.highest_uuid)
 
1210
 
 
1211
        save_dialog.destroy()
 
1212
 
 
1213
    def open_activate(self, widget):
 
1214
        open_dialogwTree = None
 
1215
        try:
 
1216
            open_dialogwTree = gtk.glade.XML (gladefile, "open_dialog")
 
1217
        except:
 
1218
            open_dialogwTree = gtk.glade.XML (devel_gladefile, "open_dialog")
 
1219
        open_dialog = open_dialogwTree.get_widget("open_dialog")
 
1220
        open_dialog.set_transient_for(self.main_window)
 
1221
        try:
 
1222
            open_dialog.set_icon_from_file(window_icon_file)
 
1223
        except:
 
1224
            pass
 
1225
 
 
1226
        result = open_dialog.run()
 
1227
        if (result == gtk.RESPONSE_OK):
 
1228
            self.filename = open_dialog.get_filename()
 
1229
 
 
1230
            self.comics = fileops.load_gco_file(self.filename)
 
1231
            if (self.comics != None):
 
1232
                self.file_modified = False
 
1233
                self.set_window_title()
 
1234
                self.comics.sort(comiclist.comic_compare_title)
 
1235
                for comic in self.comics:
 
1236
                    comic.get_issues().sort(comiclist.issue_compare_issue_number)
 
1237
                self.fill_comics_rows (self.comics)
 
1238
                start_uuid = int(fileops.get_file_uuid(self.filename))
 
1239
                self.highest_uuid = str(start_uuid)
 
1240
                self.uuid_gen = comiclist.uuid_generator(start_uuid)
 
1241
            else:
 
1242
                msg = gtk.MessageDialog(self.main_window, gtk.DIALOG_MODAL, gtk.MESSAGE_INFO, gtk.BUTTONS_OK, "Unable to load file " + self.filename + ".")
 
1243
                result = msg.run()
 
1244
                msg.destroy()
 
1245
 
 
1246
        open_dialog.destroy()