mirror of
https://github.com/gryf/pygtktalog.git
synced 2025-12-17 11:30:19 +01:00
786 lines
30 KiB
Python
786 lines
30 KiB
Python
# This Python file uses the following encoding: utf-8
|
|
#
|
|
# Author: Roman 'gryf' Dobosz gryf@elysium.pl
|
|
#
|
|
# Copyright (C) 2007 by Roman 'gryf' Dobosz
|
|
#
|
|
# This file is part of pyGTKtalog.
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
# -------------------------------------------------------------------------
|
|
|
|
__version__ = "0.8"
|
|
licence = \
|
|
"""
|
|
GPL v2
|
|
http://www.gnu.org/licenses/gpl.txt
|
|
"""
|
|
|
|
import os.path
|
|
from utils import deviceHelper
|
|
from gtkmvc import Controller
|
|
|
|
from c_config import ConfigController
|
|
from views.v_config import ConfigView
|
|
from models.m_config import ConfigModel
|
|
|
|
import views.v_dialogs as Dialogs
|
|
|
|
import gtk
|
|
|
|
import datetime
|
|
|
|
class MainController(Controller):
|
|
"""Controller for main application window"""
|
|
scan_cd = False
|
|
widgets = (
|
|
"discs","files",
|
|
'save1','save_as1','cut1','copy1','paste1','delete1','add_cd','add_directory1',
|
|
'tb_save','tb_addcd','tb_find','nb_dirs','description',
|
|
)
|
|
widgets_all = (
|
|
"discs","files",
|
|
'file1','edit1','add_cd','add_directory1','help1',
|
|
'tb_save','tb_addcd','tb_find','tb_new','tb_open','tb_quit',
|
|
'nb_dirs','description',
|
|
)
|
|
|
|
widgets_cancel = ('cancel','cancel1')
|
|
|
|
def __init__(self, model):
|
|
"""Initialize controller"""
|
|
Controller.__init__(self, model)
|
|
return
|
|
|
|
def register_view(self, view):
|
|
Controller.register_view(self, view)
|
|
|
|
# Make widget set non active
|
|
for widget in self.widgets:
|
|
self.view[widget].set_sensitive(False)
|
|
|
|
# Make not active "Cancel" button and menuitem
|
|
for widget in self.widgets_cancel:
|
|
self.view[widget].set_sensitive(False)
|
|
|
|
# hide "debug" button, if production
|
|
# (i.e. python OT running with -OO option)
|
|
if __debug__:
|
|
self.view['debugbtn'].show()
|
|
else:
|
|
self.view['debugbtn'].hide()
|
|
|
|
# load configuration/defaults and set it to properties
|
|
self.view['toolbar1'].set_active(self.model.config.confd['showtoolbar'])
|
|
if self.model.config.confd['showtoolbar']:
|
|
self.view['maintoolbar'].show()
|
|
else:
|
|
self.view['maintoolbar'].hide()
|
|
statusbar_state = self.model.config.confd['showstatusbar']
|
|
self.view['status_bar1'].set_active(statusbar_state)
|
|
if self.model.config.confd['showstatusbar']:
|
|
self.view['statusprogress'].show()
|
|
else:
|
|
self.view['statusprogress'].hide()
|
|
self.view['hpaned1'].set_position(self.model.config.confd['h'])
|
|
self.view['vpaned1'].set_position(self.model.config.confd['v'])
|
|
self.view['main'].resize(self.model.config.confd['wx'],
|
|
self.model.config.confd['wy'])
|
|
|
|
# initialize statusbar
|
|
self.context_id = self.view['mainStatus'].get_context_id('detailed res')
|
|
self.statusbar_id = self.view['mainStatus'].push(self.context_id,
|
|
"Idle")
|
|
|
|
# initialize treeviews
|
|
self.__setup_disc_treeview()
|
|
self.__setup_files_treeview()
|
|
|
|
# in case passing catalog filename in command line, unlock gui
|
|
if self.model.filename != None:
|
|
self.__activate_ui(self.model.filename)
|
|
|
|
# generate recent menu
|
|
self.__generate_recent_menu()
|
|
|
|
# Show main window
|
|
self.view['main'].show();
|
|
return
|
|
|
|
#########################################################################
|
|
# Connect signals from GUI, like menu objects, toolbar buttons and so on.
|
|
def on_rename1_activate(self, widget):
|
|
model, iter = self.view['discs'].get_selection().get_selected()
|
|
label_old = model.get_value(iter, 1)
|
|
id = model.get_value(iter, 0)
|
|
label = Dialogs.InputDiskLabel(label_old).run()
|
|
if __debug__:
|
|
print "c_main.py: on_rename1_activate(): label:", label
|
|
if label != None and label !=label_old:
|
|
self.model.set_label(id, label)
|
|
self.model.unsaved_project = True
|
|
self.__set_title(filepath=self.model.filename, modified=True)
|
|
|
|
def on_tag_cloud_textview_motion_notify_event(self, widget):
|
|
if __debug__:
|
|
print "c_main.py: on_tag_cloud_textview_motion_notify_event():"
|
|
w = self.view['tag_cloud_textview'].get_window(gtk.TEXT_WINDOW_TEXT)
|
|
if w:
|
|
w.set_cursor(None)
|
|
|
|
def on_main_destroy_event(self, window, event):
|
|
self.__do_quit()
|
|
return True
|
|
|
|
def on_tb_quit_clicked(self,widget):
|
|
self.__do_quit()
|
|
|
|
def on_quit1_activate(self,widget):
|
|
self.__do_quit()
|
|
|
|
def on_new1_activate(self,widget):
|
|
self.__new_db()
|
|
|
|
def on_tb_new_clicked(self,widget):
|
|
self.__new_db()
|
|
|
|
def on_add_cd_activate(self,widget):
|
|
self.__add_cd()
|
|
|
|
def on_tb_addcd_clicked(self,widget):
|
|
self.__add_cd()
|
|
|
|
def on_add_directory1_activate(self, widget):
|
|
"""Show dialog for choose drectory to add from filesystem."""
|
|
self.__add_directory()
|
|
return
|
|
|
|
def on_about1_activate(self,widget):
|
|
"""Show about dialog"""
|
|
Dialogs.Abt("pyGTKtalog", __version__, "About",
|
|
["Roman 'gryf' Dobosz"], licence)
|
|
return
|
|
|
|
def on_preferences_activate(self, widget):
|
|
c = ConfigController(self.model.config)
|
|
v = ConfigView(c)
|
|
return
|
|
|
|
def on_status_bar1_activate(self, widget):
|
|
"""Toggle visibility of statusbat and progress bar."""
|
|
activity = self.view['status_bar1'].get_active()
|
|
self.model.config.confd['showstatusbar'] = activity
|
|
if self.view['status_bar1'].get_active():
|
|
self.view['statusprogress'].show()
|
|
else:
|
|
self.view['statusprogress'].hide()
|
|
|
|
def on_toolbar1_activate(self, widget):
|
|
"""Toggle visibility of toolbar bar."""
|
|
activity = self.view['toolbar1'].get_active()
|
|
self.model.config.confd['showtoolbar'] = activity
|
|
if self.view['toolbar1'].get_active():
|
|
self.view['maintoolbar'].show()
|
|
else:
|
|
self.view['maintoolbar'].hide()
|
|
|
|
def on_save1_activate(self, widget):
|
|
self.__save()
|
|
|
|
def on_tb_save_clicked(self, widget):
|
|
self.__save()
|
|
|
|
def on_save_as1_activate(self, widget):
|
|
self.__save_as()
|
|
|
|
def on_tb_open_clicked(self, widget):
|
|
self.__open()
|
|
|
|
def on_open1_activate(self, widget):
|
|
self.__open()
|
|
|
|
def on_discs_cursor_changed(self, widget):
|
|
"""Show files on right treeview, after clicking the left disc
|
|
treeview."""
|
|
model = self.view['discs'].get_model()
|
|
path, column = self.view['discs'].get_cursor()
|
|
iter = self.model.discs_tree.get_iter(path)
|
|
selected_item = self.model.discs_tree.get_value(iter,0)
|
|
self.model.get_root_entries(selected_item)
|
|
|
|
self.__get_item_info(selected_item)
|
|
return
|
|
|
|
def on_discs_row_activated(self, treeview, path, treecolumn):
|
|
"""If possible, expand or collapse branch of discs tree"""
|
|
if treeview.row_expanded(path):
|
|
treeview.collapse_row(path)
|
|
else:
|
|
treeview.expand_row(path,False)
|
|
return
|
|
|
|
def on_discs_button_press_event(self, treeview, event):
|
|
try:
|
|
path, column, x, y = treeview.get_path_at_pos(int(event.x),
|
|
int(event.y))
|
|
except TypeError:
|
|
treeview.get_selection().unselect_all()
|
|
return False
|
|
|
|
if event.button == 3:
|
|
"""show context menu"""
|
|
try:
|
|
selection = treeview.get_selection()
|
|
model, list_of_paths = selection.get_selected_rows()
|
|
except TypeError:
|
|
list_of_paths = []
|
|
|
|
if path not in list_of_paths:
|
|
treeview.get_selection().unselect_all()
|
|
treeview.get_selection().select_path(path)
|
|
|
|
iter = self.model.discs_tree.get_iter(path)
|
|
if self.model.discs_tree.get_value(iter, 3) == 1:
|
|
# if ancestor is 'root', then activate "update" menu item
|
|
self.view['update1'].set_sensitive(True)
|
|
self.view['rename1'].set_sensitive(True)
|
|
else:
|
|
self.view['update1'].set_sensitive(False)
|
|
self.view['rename1'].set_sensitive(False)
|
|
self.__popup_discs_menu(event)
|
|
|
|
# elif event.button == 1: # Left click
|
|
# """Show files on right treeview, after clicking the left disc treeview."""
|
|
# model = self.view['discs'].get_model()
|
|
# selected_item = self.model.discs_tree.get_value(self.model.discs_tree.get_iter(path),0)
|
|
# if __debug__:
|
|
# print "c_main.py, on_discs_cursor_changed()",selected_item
|
|
# self.model.get_root_entries(selected_item)
|
|
#
|
|
# self.view['details'].show()
|
|
# txt = self.model.get_file_info(selected_item)
|
|
# buf = self.view['details'].get_buffer()
|
|
# buf.set_text(txt)
|
|
# self.view['details'].set_buffer(buf)
|
|
# return
|
|
|
|
def on_expand_all1_activate(self, menuitem):
|
|
self.view['discs'].expand_all()
|
|
return
|
|
|
|
def on_collapse_all1_activate(self, menuitem):
|
|
self.view['discs'].collapse_all()
|
|
return
|
|
|
|
def on_files_cursor_changed(self,treeview):
|
|
"""Show details of selected file"""
|
|
model, paths = treeview.get_selection().get_selected_rows()
|
|
try:
|
|
itera = model.get_iter(paths[0])
|
|
if model.get_value(itera,4) == 1:
|
|
#directory, do nothin', just turn off view
|
|
'''self.view['details'].hide()
|
|
buf = self.view['details'].get_buffer()
|
|
buf.set_text('')
|
|
self.view['details'].set_buffer(buf)'''
|
|
else:
|
|
#file, show what you got.
|
|
#self.details.get_top_widget()
|
|
iter = model.get_iter(treeview.get_cursor()[0])
|
|
selected_item = self.model.files_list.get_value(iter, 0)
|
|
self.__get_item_info(selected_item)
|
|
except:
|
|
if __debug__:
|
|
print "c_main.py: on_files_cursor_changed() insufficient \
|
|
iterator"
|
|
return
|
|
|
|
def on_files_key_release_event(self, a, event):
|
|
if gtk.gdk.keyval_name(event.keyval) == 'BackSpace':
|
|
d_path, d_column = self.view['discs'].get_cursor()
|
|
if d_path and d_column:
|
|
# easy way
|
|
model = self.view['discs'].get_model()
|
|
child_iter = model.get_iter(d_path)
|
|
parent_iter = model.iter_parent(child_iter)
|
|
if parent_iter:
|
|
self.view['discs'].set_cursor(model.get_path(parent_iter))
|
|
else:
|
|
# hard way
|
|
f_model = self.view['files'].get_model()
|
|
first_iter = f_model.get_iter_first()
|
|
first_child_value = f_model.get_value(first_iter, 0)
|
|
# get two steps up
|
|
value = self.model.get_parent_discs_value(first_child_value)
|
|
parent_value = self.model.get_parent_discs_value(value)
|
|
iter = self.model.discs_tree.get_iter_first()
|
|
while iter:
|
|
current_value = self.model.discs_tree.get_value(iter,0)
|
|
if current_value == parent_value:
|
|
path = self.model.discs_tree.get_path(iter)
|
|
self.view['discs'].set_cursor(path)
|
|
iter = None
|
|
else:
|
|
iter = self.model.discs_tree.iter_next()
|
|
|
|
def on_files_row_activated(self, files_obj, row, column):
|
|
"""On directory doubleclick in files listview dive into desired
|
|
branch."""
|
|
f_iter = self.model.files_list.get_iter(row)
|
|
current_id = self.model.files_list.get_value(f_iter,0)
|
|
|
|
if self.model.files_list.get_value(f_iter,4) == 1:
|
|
# ONLY directories. files are omitted.
|
|
self.model.get_root_entries(current_id)
|
|
|
|
d_path, d_column = self.view['discs'].get_cursor()
|
|
if d_path!=None:
|
|
if not self.view['discs'].row_expanded(d_path):
|
|
self.view['discs'].expand_row(d_path,False)
|
|
|
|
iter = self.model.discs_tree.get_iter(d_path)
|
|
new_iter = self.model.discs_tree.iter_children(iter)
|
|
if new_iter:
|
|
while new_iter:
|
|
current_value = self.model.discs_tree.get_value(new_iter,0)
|
|
if current_value == current_id:
|
|
path = self.model.discs_tree.get_path(new_iter)
|
|
self.view['discs'].set_cursor(path)
|
|
new_iter = self.model.discs_tree.iter_next(new_iter)
|
|
return
|
|
|
|
def on_cancel1_activate(self, widget):
|
|
self.__abort()
|
|
|
|
def on_cancel_clicked(self, widget):
|
|
self.__abort()
|
|
|
|
def on_tb_find_clicked(self, widget):
|
|
# TODO: implement searcher
|
|
return
|
|
|
|
def recent_item_response(self, path):
|
|
self.__open(path)
|
|
return
|
|
|
|
def on_update1_activate(self, menu_item):
|
|
"""Update disc under cursor position"""
|
|
|
|
# determine origin label and filepath
|
|
path = self.view['discs'].get_cursor()
|
|
filepath, label = self.model.get_label_and_filepath(path)
|
|
|
|
if self.model.get_source(path) == self.model.CD:
|
|
if self.__add_cd(label):
|
|
self.model.delete(self.model.discs_tree.get_iter(path[0],0))
|
|
pass
|
|
elif self.model.get_source(path) == self.model.DR:
|
|
if self.__add_directory(filepath, label):
|
|
self.model.delete(self.model.discs_tree.get_iter(path[0]))
|
|
pass
|
|
return
|
|
|
|
def on_delete2_activate(self, menu_item):
|
|
model = self.view['discs'].get_model()
|
|
try:
|
|
path, column = self.view['discs'].get_cursor()
|
|
selected_iter = self.model.discs_tree.get_iter(path)
|
|
except:
|
|
return
|
|
if self.model.config.confd['delwarn']:
|
|
name = self.model.discs_tree.get_value(selected_iter,1)
|
|
obj = Dialogs.Qst('Delete %s' % name, 'Delete %s?' % name,
|
|
'Object will be permanently removed.')
|
|
if not obj.run():
|
|
return
|
|
self.model.delete(selected_iter)
|
|
self.model.unsaved_project = True
|
|
self.__set_title(filepath=self.model.filename, modified=True)
|
|
return
|
|
|
|
def on_debugbtn_clicked(self,widget):
|
|
"""Debug. To remove in stable version, including button in GUI"""
|
|
if __debug__:
|
|
print "\nc_main.py: on_debugbtn_clicked()"
|
|
print "------"
|
|
print "unsaved_project = %s" % self.model.unsaved_project
|
|
print "filename = %s" % self.model.filename
|
|
print "internal_filename = %s" % self.model.internal_dirname
|
|
print "db_connection = %s" % self.model.db_connection
|
|
print "abort = %s" % self.model.abort
|
|
print "self.model.config.recent = %s" % self.model.config.recent
|
|
print "source: %s" % self.model.source
|
|
|
|
#####################
|
|
# observed properetis
|
|
def property_statusmsg_value_change(self, model, old, new):
|
|
if self.statusbar_id != 0:
|
|
self.view['mainStatus'].remove(self.context_id, self.statusbar_id)
|
|
self.statusbar_id = self.view['mainStatus'].push(self.context_id,
|
|
"%s" % new)
|
|
return
|
|
|
|
def property_busy_value_change(self, model, old, new):
|
|
if new != old:
|
|
for w in self.widgets_all:
|
|
self.view[w].set_sensitive(not new)
|
|
for widget in self.widgets_cancel:
|
|
self.view[widget].set_sensitive(new)
|
|
if not new and self.scan_cd:
|
|
self.scan_cd = False
|
|
# umount/eject cd
|
|
ejectapp = self.model.config.confd['ejectapp']
|
|
if self.model.config.confd['eject'] and ejectapp:
|
|
msg = deviceHelper.eject_cd(ejectapp,
|
|
self.model.config.confd['cd'])
|
|
if msg != 'ok':
|
|
Dialogs.Wrn("error ejecting device - pyGTKtalog",
|
|
"Cannot eject device pointed to %s" %
|
|
self.model.config.confd['cd'],
|
|
"Last eject message:\n%s" % msg)
|
|
else:
|
|
msg = deviceHelper.volumount(self.model.config.confd['cd'])
|
|
if msg != 'ok':
|
|
Dialogs.Wrn("error unmounting device - pyGTKtalog",
|
|
"Cannot unmount device pointed to %s" %
|
|
self.model.config.confd['cd'],
|
|
"Last umount message:\n%s" % msg)
|
|
return
|
|
|
|
def property_progress_value_change(self, model, old, new):
|
|
self.view['progressbar1'].set_fraction(new)
|
|
return
|
|
|
|
#########################
|
|
# private class functions
|
|
def __open(self, path=None):
|
|
"""Open catalog file"""
|
|
confirm = self.model.config.confd['confirmabandon']
|
|
if self.model.unsaved_project and confirm:
|
|
obj = Dialogs.Qst('Unsaved data - pyGTKtalog','There is not saved \
|
|
database','Pressing "Ok" will abandon catalog.')
|
|
if not obj.run():
|
|
return
|
|
|
|
if not path:
|
|
path = Dialogs.LoadDBFile().run()
|
|
|
|
if path:
|
|
if not self.model.open(path):
|
|
Dialogs.Err("Error opening file - pyGTKtalog","Cannot open \
|
|
file %s." % path)
|
|
else:
|
|
self.__generate_recent_menu()
|
|
self.__activate_ui(path)
|
|
return
|
|
|
|
def __save(self):
|
|
"""Save catalog to file"""
|
|
if self.model.filename:
|
|
self.model.save()
|
|
self.__set_title(filepath=self.model.filename)
|
|
else:
|
|
self.__save_as()
|
|
pass
|
|
|
|
def __save_as(self):
|
|
"""Save database to file under different filename."""
|
|
path = Dialogs.ChooseDBFilename().show_dialog()
|
|
if path:
|
|
ret, err = self.model.save(path)
|
|
if ret:
|
|
self.model.config.add_recent(path)
|
|
self.__set_title(filepath=path)
|
|
else:
|
|
Dialogs.Err("Error writing file - pyGTKtalog","Cannot write \
|
|
file %s." % path, "%s" % err)
|
|
|
|
def __add_cd(self, label=None):
|
|
"""Add directory structure from cd/dvd disc"""
|
|
mount = deviceHelper.volmount(self.model.config.confd['cd'])
|
|
if mount == 'ok':
|
|
guessed_label = deviceHelper.volname(self.model.config.confd['cd'])
|
|
if not label:
|
|
label = Dialogs.InputDiskLabel(guessed_label).run()
|
|
if label != None:
|
|
self.scan_cd = True
|
|
for widget in self.widgets_all:
|
|
self.view[widget].set_sensitive(False)
|
|
self.model.source = self.model.CD
|
|
self.model.scan(self.model.config.confd['cd'],label)
|
|
self.model.unsaved_project = True
|
|
self.__set_title(filepath=self.model.filename, modified=True)
|
|
return True
|
|
else:
|
|
Dialogs.Wrn("Error mounting device - pyGTKtalog",
|
|
"Cannot mount device pointed to %s" %
|
|
self.model.config.confd['cd'],
|
|
"Last mount message:\n%s" % mount)
|
|
return False
|
|
|
|
def __add_directory(self, path=None, label=None):
|
|
if not label or not path:
|
|
res = Dialogs.PointDirectoryToAdd().run()
|
|
if res !=(None,None):
|
|
path = res[1]
|
|
label = res[0]
|
|
else:
|
|
return False
|
|
|
|
self.scan_cd = False
|
|
self.model.source = self.model.DR
|
|
self.model.scan(path, label)
|
|
self.model.unsaved_project = True
|
|
self.__set_title(filepath=self.model.filename, modified=True)
|
|
return True
|
|
|
|
def __do_quit(self):
|
|
"""Quit and save window parameters to config file"""
|
|
# check if any unsaved project is on go.
|
|
if self.model.unsaved_project and \
|
|
self.model.config.confd['confirmquit']:
|
|
if not Dialogs.Qst('Quit application - pyGTKtalog',
|
|
'Do you really want to quit?',
|
|
"Current database is not saved, any changes \
|
|
will be lost.").run():
|
|
return
|
|
|
|
self.__store_settings()
|
|
self.model.cleanup()
|
|
gtk.main_quit()
|
|
return False
|
|
|
|
def __new_db(self):
|
|
|
|
self.__tag_cloud()
|
|
|
|
"""Create new database file"""
|
|
if self.model.unsaved_project:
|
|
if not Dialogs.Qst('Unsaved data - pyGTKtalog',
|
|
"Current database isn't saved",
|
|
'All changes will be lost. \
|
|
Do you really want to abandon it?').run():
|
|
return
|
|
self.model.new()
|
|
|
|
# clear "details" buffer
|
|
'''txt = ""
|
|
buf = self.view['details'].get_buffer()
|
|
buf.set_text(txt)
|
|
self.view['details'].set_buffer(buf)'''
|
|
|
|
self.__activate_ui()
|
|
|
|
return
|
|
|
|
def __setup_disc_treeview(self):
|
|
"""Setup TreeView discs widget as tree."""
|
|
self.view['discs'].set_model(self.model.discs_tree)
|
|
|
|
c = gtk.TreeViewColumn('Filename')
|
|
|
|
# one row contains image and text
|
|
cellpb = gtk.CellRendererPixbuf()
|
|
cell = gtk.CellRendererText()
|
|
c.pack_start(cellpb, False)
|
|
c.pack_start(cell, True)
|
|
c.set_attributes(cellpb, stock_id=2)
|
|
c.set_attributes(cell, text=1)
|
|
|
|
self.view['discs'].append_column(c)
|
|
|
|
# registration of treeview signals:
|
|
|
|
return
|
|
|
|
def __setup_tags_treeview(self):
|
|
"""Setup TreeView discs widget as tree."""
|
|
self.view['tags'].set_model(self.model.tagsTree)
|
|
|
|
c = gtk.TreeViewColumn('Filename')
|
|
|
|
# one row contains image and text
|
|
cellpb = gtk.CellRendererPixbuf()
|
|
cell = gtk.CellRendererText()
|
|
c.pack_start(cellpb, False)
|
|
c.pack_start(cell, True)
|
|
c.set_attributes(cellpb, stock_id=2)
|
|
c.set_attributes(cell, text=1)
|
|
|
|
self.view['discs'].append_column(c)
|
|
|
|
# registration of treeview signals:
|
|
|
|
return
|
|
|
|
def __setup_files_treeview(self):
|
|
"""Setup TreeView files widget, as columned list."""
|
|
self.view['files'].set_model(self.model.files_list)
|
|
|
|
self.view['files'].get_selection().set_mode(gtk.SELECTION_MULTIPLE)
|
|
|
|
c = gtk.TreeViewColumn('Filename')
|
|
cellpb = gtk.CellRendererPixbuf()
|
|
cell = gtk.CellRendererText()
|
|
c.pack_start(cellpb, False)
|
|
c.pack_start(cell, True)
|
|
c.set_attributes(cellpb, stock_id=6)
|
|
c.set_attributes(cell, text=1)
|
|
|
|
c.set_sort_column_id(1)
|
|
c.set_resizable(True)
|
|
self.view['files'].append_column(c)
|
|
|
|
c = gtk.TreeViewColumn('Size',gtk.CellRendererText(), text=2)
|
|
c.set_sort_column_id(2)
|
|
c.set_resizable(True)
|
|
self.view['files'].append_column(c)
|
|
|
|
c = gtk.TreeViewColumn('Date',gtk.CellRendererText(), text=3)
|
|
c.set_sort_column_id(3)
|
|
c.set_resizable(True)
|
|
self.view['files'].append_column(c)
|
|
|
|
c = gtk.TreeViewColumn('Category',gtk.CellRendererText(), text=5)
|
|
c.set_sort_column_id(5)
|
|
c.set_resizable(True)
|
|
self.view['files'].append_column(c)
|
|
|
|
# registration of treeview signals:
|
|
|
|
return
|
|
|
|
def __abort(self):
|
|
"""When scanning thread is runing and user push the cancel button,
|
|
models abort attribute trigger cancelation for scan operation"""
|
|
self.model.abort = True
|
|
return
|
|
|
|
def __activate_ui(self, name=None):
|
|
"""Make UI active, and set title"""
|
|
self.model.unsaved_project = False
|
|
self.__set_title(filepath=name)
|
|
for widget in self.widgets:
|
|
try:
|
|
self.view[widget].set_sensitive(True)
|
|
except:
|
|
pass
|
|
# PyGTK FAQ entry 23.20
|
|
while gtk.events_pending():
|
|
gtk.main_iteration()
|
|
return
|
|
|
|
def __set_title(self, filepath=None, modified=False):
|
|
"""Set main window title"""
|
|
if modified:
|
|
mod = " *"
|
|
else:
|
|
mod = ""
|
|
|
|
if filepath:
|
|
self.view['main'].set_title("%s - pyGTKtalog%s" %
|
|
(os.path.basename(filepath), mod))
|
|
else:
|
|
self.view['main'].set_title("untitled - pyGTKtalog%s" % mod)
|
|
return
|
|
|
|
def __store_settings(self):
|
|
"""Store window size and pane position in config file (using config
|
|
object from model)"""
|
|
if self.model.config.confd['savewin']:
|
|
self.model.config.confd['wx'], self.model.config.confd['wy'] = \
|
|
self.view['main'].get_size()
|
|
if self.model.config.confd['savepan']:
|
|
self.model.config.confd['h'] = self.view['hpaned1'].get_position()
|
|
self.model.config.confd['v'] = self.view['vpaned1'].get_position()
|
|
self.model.config.save()
|
|
return
|
|
|
|
def __popup_discs_menu(self, event):
|
|
self.view['discs_popup'].popup(None, None, None, event.button,
|
|
event.time)
|
|
self.view['discs_popup'].show_all()
|
|
return
|
|
|
|
def __generate_recent_menu(self):
|
|
self.recent_menu = gtk.Menu()
|
|
for i in self.model.config.recent:
|
|
name = os.path.basename(i)
|
|
item = gtk.MenuItem("%s" % name)
|
|
item.connect_object("activate", self.recent_item_response, i)
|
|
self.recent_menu.append(item)
|
|
item.show()
|
|
self.view['recent_files1'].set_submenu(self.recent_menu)
|
|
return
|
|
|
|
def __get_item_info(self, item):
|
|
self.view['description'].show()
|
|
set = self.model.get_file_info(item)
|
|
|
|
buf = self.view['description'].get_buffer()
|
|
if set.has_key('description'):
|
|
buf.set_text(set['description'])
|
|
else:
|
|
buf.set_text('')
|
|
self.view['description'].set_buffer(buf)
|
|
|
|
if set.has_key('thumbnail'):
|
|
self.view['thumb'].set_from_file(set['thumbnail'])
|
|
self.view['thumb'].show()
|
|
else:
|
|
self.view['thumb'].hide()
|
|
return
|
|
|
|
def __tag_cloud(self):
|
|
"""generate tag cloud"""
|
|
# TODO: checkit!
|
|
def tag_cloud_click(tag, textview, event, iter, e):
|
|
"""react on click on connected tag items"""
|
|
if event.type == gtk.gdk.BUTTON_RELEASE:
|
|
print tag.get_property('name')
|
|
elif event.type == gtk.gdk.MOTION_NOTIFY:
|
|
w = \
|
|
self.view['tag_cloud_textview'].get_window(gtk.TEXT_WINDOW_TEXT)
|
|
if w:
|
|
w.set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND2))
|
|
else:
|
|
w = \
|
|
self.view['tag_cloud_textview'].get_window(gtk.TEXT_WINDOW_TEXT)
|
|
if w:
|
|
w.set_cursor(None)
|
|
|
|
|
|
def insert_blank(b, iter):
|
|
if iter.is_end() and iter.is_start():
|
|
return iter
|
|
else:
|
|
b.insert(iter, " ")
|
|
iter = b.get_end_iter()
|
|
return iter
|
|
|
|
if len(self.model.tag_cloud) > 0:
|
|
buff = gtk.TextBuffer()
|
|
for cloud in self.model.tag_cloud:
|
|
iter = insert_blank(buff, buff.get_end_iter())
|
|
tag = buff.create_tag(cloud['id'])
|
|
tag.set_property('size-points', cloud['size'])
|
|
tag.set_property('foreground', cloud['color'])
|
|
tag.connect('event', tag_cloud_click, tag)
|
|
buff.insert_with_tags(iter, cloud['name'], tag)
|
|
self.view['tag_cloud_textview'].set_buffer(buff)
|
|
|
|
pass # end of class
|