#!/usr/bin/env python
# -*- coding: UTF-8 -*-
import os, stat, time
import pygtk
pygtk.require('2.0')
import gtk
import ConfigParser as configparser

ROOT_DIR = "/home/sts/files"
TITLE = "ファイルマネージャ"
COLUMN_TEXT=0
COLUMN_NAMES = [ "ファイル名", "サイズ", "更新日" ]
CONFIG_FILE = "config.txt"

MESSAGE_ENTER  = 'パスワードを入力してください'
MESSAGE_ENTER2 = 'パスワードを入力してください\n（確認）'
#MESSAGE_ENTER2 = 'Please enter <b>password</b>:\n(confirm)'
MESSAGE_OK1 = '<b>Successful</b>'
MESSAGE_NG1 = '<b>無効なパスワードが入力されました</b>'
MESSAGE_CONFIRM_DELETE = '削除してもよろしいですか'
LABEL_ENTER = ''

def responseToDialog(entry, dialog, response):
    dialog.response(response)

def get_text(msg='',password=None):
    #base this on a message dialog
    dialog = gtk.MessageDialog(
        None,
        gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
        gtk.MESSAGE_QUESTION,
        gtk.BUTTONS_OK,
        None)

    dialog.set_markup(msg)

    #create the text input field
    if password != None:
        entry = gtk.Entry()
        entry.set_visibility(False)
        #allow the user to press enter to do ok
        entry.connect("activate", responseToDialog, dialog, gtk.RESPONSE_OK)
        #create a horizontal box to pack the entry and a label
        hbox = gtk.HBox()
        hbox.pack_start(gtk.Label(LABEL_ENTER), False, 5, 5)
        hbox.pack_end(entry)
        #some secondary text
        #dialog.format_secondary_markup("This will be used for <i>identification</i> purposes")

        dialog.vbox.pack_end(hbox, True, True, 0)

    dialog.show_all()
    dialog.run()
    text = ""
    if password != None:
        text = entry.get_text()
    dialog.destroy()
    return text

def confirm_proc(msg=''):
    #base this on a message dialog
    dialog = gtk.MessageDialog(
        None,
        gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
        gtk.MESSAGE_QUESTION,
        gtk.BUTTONS_OK_CANCEL,
        None)
    dialog.set_markup(msg)
    dialog.show_all()
    result = dialog.run()
    dialog.destroy()
    print result
    return result

def foreach(model, path, iter, selected):
    selected.append(model.get_value(iter, COLUMN_TEXT))

class PnsFilerApp:

    def __init__(self, dname = ROOT_DIR):

        cell_data_funcs = (
            None,
            self.file_size,
            #self.file_mode,
            self.file_last_changed)

        # Create a new window
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_title( TITLE )
        self.window.set_size_request(640, 300)
        self.window.connect("delete_event", self.delete_event)


        # 設定ファイルを探す
        config = {}
        if os.path.exists(CONFIG_FILE):
            for line in open(CONFIG_FILE, 'r'):
                itemList = line[:-1].split('=')
                (key, value) = tuple( itemList )
                config[ key ] = value.replace("\r","")
            print config
            #conf = configparser.SafeConfigParser()
            #conf.read(CONFIG_FILE)
            #if conf.has_option("save_folder", ""):
            #    x = conf.getint("save_folder", "")
            ROOT_DIR = config["save_folder"]
        else:
            return


        vbox = gtk.VBox(False, 0)

        self.contextMenu = gtk.Menu()

        buf = "圧縮"
        menu_items = gtk.MenuItem(buf)
        self.contextMenu.append(menu_items)
        menu_items.connect("activate", self.menuitem_response, buf)
        menu_items.show()

        buf = "圧縮(パスワード付き)"
        menu_items = gtk.MenuItem(buf)
        self.contextMenu.append(menu_items)
        menu_items.connect("activate", self.menuitem_response, buf)
        menu_items.show()

        buf = "解凍"
        menu_items = gtk.MenuItem(buf)
        self.contextMenu.append(menu_items)
        menu_items.connect("activate", self.menuitem_response, buf)
        menu_items.show()

        buf = "削除"
        menu_items = gtk.MenuItem(buf)
        self.contextMenu.append(menu_items)
        menu_items.connect("activate", self.menuitem_response, buf)
        menu_items.show()

        toolbar = gtk.Toolbar()
        vbox.pack_start(toolbar, False, False, 0)

        self.upButton = gtk.ToolButton(gtk.STOCK_REFRESH);
        self.upButton.set_is_important(True)
        self.upButton.set_sensitive(True)
        toolbar.insert(self.upButton, -1)
        self.upButton.connect("clicked", self.on_refresh_clicked)

        listmodel = self.make_list(dname)
        self.treeview = gtk.TreeView()

        self.tvcolumn = [None] * len(COLUMN_NAMES)
        cellpb = gtk.CellRendererPixbuf()
        self.tvcolumn[0] = gtk.TreeViewColumn(COLUMN_NAMES[0], cellpb)
        self.tvcolumn[0].set_cell_data_func(cellpb, self.file_pixbuf)
        cell = gtk.CellRendererText()
        self.tvcolumn[0].pack_start(cell, False)
        self.tvcolumn[0].set_cell_data_func(cell, self.file_name)
        self.treeview.append_column(self.tvcolumn[0])

        for n in range(1, len(COLUMN_NAMES)):
            cell = gtk.CellRendererText()
            self.tvcolumn[n] = gtk.TreeViewColumn(COLUMN_NAMES[n], cell)
            if n == 1:
                cell.set_property('xalign', 1.0)
            self.tvcolumn[n].set_cell_data_func(cell, cell_data_funcs[n])
            self.treeview.append_column(self.tvcolumn[n])

        selection = self.treeview.get_selection()
        selection.set_mode(gtk.SELECTION_MULTIPLE)
        selection.connect('changed', self.on_tree_selection_changed2)

        self.treeview.connect('row-activated', self.open_file)
        self.treeview.connect('button-press-event' , self.on_treeview_button_press_event)
        self.scrolledwindow = gtk.ScrolledWindow()
        self.scrolledwindow.add(self.treeview)

        vbox.pack_start(self.scrolledwindow, True, True, 2)

        self.treeview.set_model(listmodel)

        vbox.show()
        self.window.add(vbox)

        self.window.show_all()

        return

    def delete_event(self, widget, event, data=None):
        gtk.main_quit()
        return False

    def button_press(self, widget, event):
        if event.type == gtk.gdk.BUTTON_PRESS:
            print "PRESS"
            widget.popup(None, None, None, event.button, event.time)
            return True
        return False

    # Print a string when a menu item is selected
    def menuitem_response(self, widget, string):
        print "%s" % string
        selected = []
        selection = self.treeview.get_selection()
        selection.selected_foreach(foreach, selected)
        print selected
        password = ""

        if string == "圧縮":
            base = self.dirname + "/"
            import commands
            cmd = '{0} {1} {2} {3}'.format("/usr/bin/zip", "-j", base + selected[0]+".zip", base + selected[0])
            print cmd
            check = commands.getoutput(cmd)
            print check
            get_text(MESSAGE_OK1)

        if string == "圧縮(パスワード付き)":
            pass1 = get_text(MESSAGE_ENTER,password)
            pass2 = None
            if pass1 != "":
                pass2 = get_text(MESSAGE_ENTER2,password)
            if pass1 == pass2:
                password = pass1
                get_text(MESSAGE_OK1)
            else:
                get_text(MESSAGE_NG1)

        if string == "解凍":
            base = self.dirname + "/"
            import commands
            cmd = '{0} {1} {2} {3} {4}'.format("/usr/bin/unzip", "-o", base + selected[0], "-d", base)
            print cmd
            check = commands.getoutput(cmd)
            print check
            get_text(MESSAGE_OK1)

        if string == "解凍(パスワード付き)":
            base = self.dirname + "/"
            import commands
            cmd = '{0} {1} {2} {3} {4}'.format("/usr/bin/unzip", "-o", base + selected[0]+".zip", "-d", base)
            print cmd
            check = commands.getoutput(cmd)
            print check
            get_text(MESSAGE_OK1)

        if string == "削除":
            if confirm_proc(MESSAGE_CONFIRM_DELETE) == gtk.RESPONSE_OK:
                base = self.dirname + "/"
                import commands
                cmd = '{0} {1} {2}'.format("rm", "-Rf", base + selected[0])
                print cmd
                check = commands.getoutput(cmd)
                print check
                #get_text(MESSAGE_OK1)

        new_model = self.make_list(self.dirname)
        self.treeview.set_model(new_model)

    def on_treeview_button_press_event(self, treeview, event):
        print "treeview event"
        if event.button == 1:
            print event.button
            print self.treeview.get_selection()
            pass

        if event.button == 3:
            print event.button
            x = int(event.x)
            y = int(event.y)
            time = event.time
            pthinfo = self.treeview.get_path_at_pos(x, y)
            print pthinfo
            if pthinfo is not None:
                path, col, cellx, celly = pthinfo
                self.treeview.grab_focus()
                self.treeview.set_cursor( path, col, 0)

                self.contextMenu.popup(None,
                    None,
                    None,
                    event.button,
                    event.time)

            return True

    def on_refresh_clicked(self, widget):
        new_model = self.make_list(self.dirname)
        self.treeview.set_model(new_model)

    def on_tree_selection_changed2(self, selection):
        selected = []
        selection.selected_foreach(foreach, selected)
        print selected

    def make_list(self, dname=None):
        if not dname:
            self.dirname = os.path.expanduser('~')
        else:
            self.dirname = os.path.abspath(dname)
        #self.window.set_title(self.dirname)
        files = [f for f in os.listdir(self.dirname) if f[0] <> '.']
        files.sort()
        files = ['..'] + files
        listmodel = gtk.ListStore(object)
        for f in files:
            listmodel.append([f])
        return listmodel

    def open_file(self, treeview, path, column):
        model = treeview.get_model()
        iter = model.get_iter(path)
        filename = os.path.join(self.dirname, model.get_value(iter, 0))
        filestat = os.stat(filename)
        if stat.S_ISDIR(filestat.st_mode):
            if filename.startswith(ROOT_DIR) == True and filename.startswith(ROOT_DIR+"/..") == False:
                print filename
                print filestat.st_mode
                new_model = self.make_list(filename)
                treeview.set_model(new_model)
        return

    def file_pixbuf(self, column, cell, model, iter):
        filename = os.path.join(self.dirname, model.get_value(iter, 0))
        filestat = os.stat(filename)
        if stat.S_ISDIR(filestat.st_mode):
            cell.set_property("stock-id", gtk.STOCK_DIRECTORY)
        else:
            cell.set_property("stock-id", gtk.STOCK_FILE)
        return

    def file_name(self, column, cell, model, iter):
        cell.set_property('text', model.get_value(iter, 0))
        return

    def file_size(self, column, cell, model, iter):
        filename = os.path.join(self.dirname, model.get_value(iter, 0))
        filestat = os.stat(filename)
        cell.set_property('text', filestat.st_size)
        return

    def file_mode(self, column, cell, model, iter):
        filename = os.path.join(self.dirname, model.get_value(iter, 0))
        filestat = os.stat(filename)
        cell.set_property('text', oct(stat.S_IMODE(filestat.st_mode)))
        return

    def file_last_changed(self, column, cell, model, iter):
        filename = os.path.join(self.dirname, model.get_value(iter, 0))
        filestat = os.stat(filename)
        cell.set_property('text', time.ctime(filestat.st_mtime))
        return

def main():
    gtk.main()

if __name__ == "__main__":
    app = PnsFilerApp()
    main()