MinimPy Code

#!/usr/bin/env python

import sys
import os
import functions

try:
    import pygtk
    pygtk.require("2.0")
except:
    print("pygtk Not Availible")
    sys.exit(1)
try:
    import gtk
    import gobject
except:
    print("GTK Not Availible")
    sys.exit(1)

class PrefWin(object):
    def delete_event(self, widget, event):
        self.window.destroy()

    def __init__(self, parent):
        self._ = parent._
        self.parent = parent
        self.initial_locale = self.parent.config.get('interface', 'locale')
        self.locales = os.walk(os.path.join(os.path.dirname(sys.argv[0]), 'locale')).next()[1]
        self.locales = [locale for locale in self.locales if set(['parse_locale.py',
        'locale.dat', 'readme', 'locale.cfg']) == set(os.walk(
        os.path.join(os.path.dirname(sys.argv[0]), 'locale', locale)).next()[-1])]
            
        self.layout_dirs = ['ltr', 'rtl']
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_title(self._("minimpy_program_preferences"))
        self.window.connect("delete_event", self.delete_event)
        self.window.set_border_width(10)
        self.window.set_transient_for(parent.window)
        self.window.set_modal(True)

        table = gtk.Table(11, 2)

        hb = gtk.HBox(False, 5)
        self.set_tab_pos_cbo = gtk.combo_box_new_text()
        self.set_tab_pos_cbo.append_text(self._("left"))
        self.set_tab_pos_cbo.append_text(self._("right"))
        self.set_tab_pos_cbo.append_text(self._("top"))
        self.set_tab_pos_cbo.append_text(self._("bottom"))
        self.set_tab_pos_cbo.set_active(parent.notebook.get_tab_pos())
        label = gtk.Label(self._("program_tabs_position"))
        hb.pack_start(label, False, False)
        hb.pack_start(self.set_tab_pos_cbo, False, False)
        table.attach(hb, 0, 1, 0, 1)

        hb = gtk.HBox(False, 5)
        self.set_locale_cbo = gtk.combo_box_new_text()
        for locale in self.locales:
            self.set_locale_cbo.append_text(self._(locale))
        self.set_locale_cbo.set_active(self.locales.index(self.parent.config.get('interface', 'locale')))
        label = gtk.Label('*' + self._("interface_language"))
        hb.pack_start(label, False, False)
        hb.pack_start(self.set_locale_cbo, False, False)
        sep = gtk.VSeparator()
        hb.pack_start(sep, False, False)
        self.set_layout_dir_cbo = gtk.combo_box_new_text()
        self.set_layout_dir_cbo.append_text(self._("ltr"))
        self.set_layout_dir_cbo.append_text(self._("rtl"))
        self.set_layout_dir_cbo.set_active(self.layout_dirs.index(self.parent.config.get('interface', 'layout_dir')))
        label = gtk.Label(self._("interface_direction"))
        hb.pack_start(label, False, False)
        hb.pack_start(self.set_layout_dir_cbo, False, False)
        table.attach(hb, 1, 2, 0, 1)

        sep = gtk.HSeparator()
        table.attach(sep, 0, 2, 1, 2)
        
        self.load_recent_chk = gtk.CheckButton(self._("load_last_project_on_startup"))
        self.load_recent_chk.set_active(self.parent.config.getboolean('project', 'load_recent'))
        table.attach(self.load_recent_chk, 0, 2, 2, 3)

        self.batch_allocation_chk = gtk.CheckButton(self._("batch_allocation"))
        self.batch_allocation_chk.set_active(self.parent.config.getboolean('interface', 'batch_allocation'))
        table.attach(self.batch_allocation_chk, 0, 2, 4, 5)

        self.alt_random_chk = gtk.CheckButton(self._("alternate_random"))
        self.alt_random_chk.set_active(self.parent.config.getboolean('operations', 'alt_random'))
        table.attach(self.alt_random_chk, 0, 2, 5, 6)

        hb = gtk.HBox(False)
        self.backup_network_file_chk = gtk.CheckButton(self._("backup_sync"))
        self.backup_network_file_chk.set_active(self.parent.config.getboolean('operations', 'backup_network'))
        hb.pack_start(self.backup_network_file_chk, False, False)
        arrow = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_IN)
        hb.pack_start(arrow, False, False)
        table.attach(hb, 0, 1, 6, 7)

        self.backup_network_file_path_button = gtk.FileChooserButton(self._("backup_path"))
        self.backup_network_file_path_button.set_title(self._('select_backup_path'))
        self.backup_network_file_path_button.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
        self.backup_network_file_path_button.set_current_folder(self.parent.config.get('operations', 'backup_network_path'))
        table.attach(self.backup_network_file_path_button, 1, 2, 6, 7)

        self.cach_cred_chk = gtk.CheckButton(self._("store_account"))
        self.cach_cred_chk.set_active(self.parent.config.getboolean('operations', 'cach_cred'))
        table.attach(self.cach_cred_chk, 0, 1, 7, 8)
        
        hb = gtk.HBox()
        button = gtk.Button(self._('show_cached_data'))
        button.connect('clicked', self.clear_cach_button)
        hb.pack_start(button, False, False)
        table.attach(hb, 1, 2, 7, 8)

        sep = gtk.HSeparator()
        table.attach(sep, 0, 2, 8, 9)

        self.cached_cred_vbox = gtk.VBox()
        sw = gtk.ScrolledWindow()
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        sw.add_with_viewport(self.cached_cred_vbox)
        self.cached_cred_sw = sw
        table.attach(sw, 0, 2, 9, 10)

        sep = gtk.HSeparator()
        table.attach(sep, 0, 2, 10, 11)


        label = gtk.Label('*' + self._("need_restart"))
        table.attach(label, 0, 1, 11, 12, xoptions=gtk.EXPAND)

        hb = gtk.HBox(True, 5)
        btn = gtk.Button(None, gtk.STOCK_SAVE)
        btn.connect("clicked", self.save_prefs)
        hb.pack_start(btn, False)
        btn = gtk.Button(None, gtk.STOCK_CLOSE)
        btn.connect("clicked", self.close_window)
        hb.pack_start(btn, False)
        table.attach(hb, 1, 2, 11, 12, xoptions=gtk.EXPAND)

        #btn = gtk.Button(None, gtk.STOCK_CLOSE)
        #btn.connect("clicked", self.close_window)
        #table.attach(btn, 1, 2, 11, 12, xoptions=gtk.EXPAND)

        self.window.add(table)
        self.window.show_all()
        self.cached_cred_sw.hide()

    def clear_cach_button(self, button, data=None):
        if button.get_label() == self._('show_cached_data'):
            button.set_label(self._('hide_cached_data'))
        else:
            button.set_label(self._('show_cached_data'))
            self.files_treeview.destroy()
            self.cached_cred_sw.hide()
            return
        path_found = True
        cach_empty = False
        platform = sys.platform # if linux linux2 if windows win32
        if platform == 'linux2':
            path = os.path.expanduser('~/.subversion/auth/svn.simple')
        elif platform == 'win32':
            path = os.path.join(os.path.expandvars('$APPDATA'), 'Subversion\\auth\\svn.simple')
        else:
            path_found = False
        if path_found:
            if os.path.exists(path) and os.path.isdir(path):
                files = os.listdir(path)
                files = map(lambda x: os.path.join(path, x), files)
                files = filter(os.path.isfile, files)
                #files = dict([(os.path.basename(x), x) for x in files])
                if len(files):
                    self.display_cached_data(files)
                    return
                else:
                    # this probably means the cach folder is empty
                    cach_empty = True
            else:
                path_found = False

    def is_cached_data_file(self, file_name):
        # every other line of file must be 'K n' and 'V m' valuse.
        # n and m must be the lengths of the following lines
        # ther must be a line == 'K 8' followed by a line == 'username' followed by line == 'V m' followed by username of len m
        # the last line mus be a 'END'
        fp = open(file_name)
        lines = fp.readlines()
        fp.close()
        lines = map(str.strip, lines)
        if lines[-1] != 'END': return (False, self._("last_line_need_end"))
        lines = lines[:-1]
        if not all([line.startswith('K') for line in lines[::4]]): return (False, self._("every_fourth_line"))
        if not all([line.startswith('V') for line in lines[2::4]]): return (False, self._("every_fourth_line_1"))
        for i in range(0, len(lines)-1, 2):
            if lines[i].split()[1].isdigit():
                length = int(lines[i].split()[1])
            else:
                return (False, self._("m_n_must_be_integers"))
            if len(lines[i+1]) != length:
                return (False, self._("must_be_lengths_of_lines"))
        if lines[-3] != 'username':
            return (False, self._("no_username_line"))
        if lines[-7] != 'svn:realmstring':
            return (False, self._("no_realm_line"))
        return [True, lines[-1], lines[-5]]

    def display_cached_data(self, files):
        self.cached_files = []
        accounts = []
        for f in files:
            try:
                ret = self.is_cached_data_file(f)
            except:
                continue
            if ret[0]:
                self.cached_files.append(f)
                account = ret[1:]
                account.append(False)
                accounts.append(account)
        column_types = (gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_BOOLEAN)
        column_names = (self._('username'), self._('realm_col'), self._('clear'))
        liststore = gtk.ListStore(*column_types)
        treeview = gtk.TreeView(liststore)
        treeview.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH)        
        for n in range(len(column_names)):
            if n < 2:
                cell = gtk.CellRendererText()
                tvcolumn = gtk.TreeViewColumn(column_names[n], cell, text=n)
            else:
                cell = gtk.CellRendererToggle()
                cell.set_property('activatable', True)
                cell.connect('toggled', self.cach_clear_toggled, n, liststore)
                tvcolumn = gtk.TreeViewColumn(column_names[n], cell)
                tvcolumn.add_attribute(cell, 'active', n)
            treeview.append_column(tvcolumn)
        self.files_treeview = treeview
        for account in accounts:
            liststore.append(account)
        hb = gtk.HBox()
        hb.pack_start(self.files_treeview)
        self.cached_cred_vbox.pack_start(hb)
        self.cached_cred_sw.show_all()

    def cach_clear_toggled(self, cell, row, col, model):
        model[row][col] = not model[row][col]

    def save_prefs(self, widget, data=None):
        self.parent.notebook.set_tab_pos(self.set_tab_pos_cbo.get_active())
        self.parent.hbuttonbox_batch_mode.set_property('visible', self.batch_allocation_chk.get_active())
        self.parent.config.set('interface', 'tab_pos', self.set_tab_pos_cbo.get_active())
        self.parent.config.set('interface', 'locale', self.locales[self.set_locale_cbo.get_active()])
        self.parent.config.set('interface', 'layout_dir', self.layout_dirs[self.set_layout_dir_cbo.get_active()])
        self.parent.config.set('interface', 'batch_allocation', self.batch_allocation_chk.get_active())
        self.parent.config.set('project', 'load_recent', self.load_recent_chk.get_active())
        self.parent.config.set('operations', 'alt_random', self.alt_random_chk.get_active())
        self.parent.config.set('operations', 'cach_cred', self.cach_cred_chk.get_active())
        self.parent.config.set('operations', 'backup_network', self.backup_network_file_chk.get_active())
        self.parent.config.set('operations', 'backup_network_path', self.backup_network_file_path_button.get_filename())
        with open(self.parent.config_file, 'wb') as config_file:
            self.parent.config.write(config_file)
            config_file.flush()
            config_file.close()
            self.parent.config.read(self.parent.config_file)

        if self.parent.config.get('interface', 'locale') != self.initial_locale:
            msg = self._("restart_now")
            dialog = gtk.MessageDialog(self.window, flags = gtk.DIALOG_MODAL, type = gtk.MESSAGE_QUESTION, buttons=gtk.BUTTONS_YES_NO, message_format = msg)
            dialog.set_title(self._("need_restart"))
            if dialog.run() == gtk.RESPONSE_YES:
                dialog.destroy()
                self.parent.restart = True
                self.window.destroy()
                self.parent.window.destroy()
                gtk.main_quit()
                return
            dialog.destroy()

        if self.parent.config.get('interface', 'layout_dir') == 'rtl':
            gtk.widget_set_default_direction(gtk.TEXT_DIR_RTL)
        elif self.parent.config.get('interface', 'layout_dir') == 'ltr':
            gtk.widget_set_default_direction(gtk.TEXT_DIR_LTR)

        if not self.parent.trial_file_name:
            if self.parent.config.getboolean('project', 'load_recent'):
                self.parent.trial_file_name = self.parent.config.get('project', 'recent_trial')
            else:
                self.parent.trial_file_name = None
                self.parent.network_sync_user = ''
            if self.parent.trial_file_name:
                self.parent.waiting_function(self.parent.load_trial, (self.parent.trial_file_name,))
                if not self.parent.trial_file_name:
                    functions.error_dialog(self.window, self._('load_error_msg'), self._('load_error_title'))
                    self.parent.set_new_trial()
            else:
                self.parent.set_new_trial()
        if self.cached_cred_sw.get_property('visible'):
            model = self.files_treeview.get_model()
            for row in range(len(model)):
                if model[row][2]:
                    os.remove(self.cached_files[row])
        self.parent.random = functions.get_app_random(self.parent.config)
        self.window.destroy()
        
    def close_window(self, widget, data=None):
        self.window.destroy()