#!/usr/bin/env python

# Not perfected, but completely usable.
# Peter Wang (tjaden@users.sourceforge.net), 24 March 24 2000. 

import os, string
from gtk import *

notedir = ''


class MyGtkText(GtkText):
    def clear(self):
        self.delete_text(0, self.get_length())
    def get_text(self):
        return self.get_chars(0, self.get_length())
    def set_text(self, newtext):
        self.clear()
        self.insert_defaults(newtext);


class Alert(GtkWindow):
    def __init__(self, message):
        GtkWindow.__init__(self, WINDOW_DIALOG)
        self.connect('destroy', self.close)
	self.set_title('Alert')
        self.show()

        vbox = GtkVBox()
        self.add(vbox)
        vbox.show()

        label = GtkLabel(label=message)
        vbox.pack_start(label)
        label.show();
        
        button = GtkButton(label='Close')
        button.connect('clicked', self.close)
        vbox.pack_end(button)
        button.show()

    def close(self, *args):
        self.destroy()
        mainquit()

    def mainloop(self):
        self.show()
        mainloop()

	
class Page(MyGtkText):
    def __init__(self, filename, title='Untitled'):
        MyGtkText.__init__(self)
        self.filename = filename
        self.headers = { 'Title' : title }
        if os.path.exists(filename):
            self.read_file(filename)
        
    def read_file(self, filename):
        file = open(self.filename)
	strip = string.strip
        
        # header
        while 1:
            line = strip(file.readline())
            if not line: break
            
            c = string.find(line, ':')
            if c:
                field = strip(line[:c])
                info = strip(line[c+1:])
                self.headers[field] = info
            
        # body
	text = string.join(file.readlines(), '')
        self.set_text(text)

        file.close()
        
    def write_file(self):
        def write_headers(file, headers):
            for i in headers.keys():
                file.write(i + ": " + headers[i] + '\n')

        f = open(self.filename, 'w')
        write_headers(f, self.headers)
        f.write('\n')
        f.write(self.get_text())
        f.close()

    def reload(self):
        self.read_file(self.filename)

    def get_filename(self):
        return self.filename

    def get_title(self):
        return self.headers['Title']
    
    def set_title(self, title):
        self.headers['Title'] = title

    def lpr(self):
        import time
        # FIXME
        filename = '/tmp/tmp-notebook-' + os.environ['USER']
        f = open(filename, 'w')
        f.write(self.get_title() + '\n\n')
        f.write(time.ctime(time.time()) + '\n\n\n')
        f.write(self.get_text())
        f.close()
        os.system('lpr ' + filename)

	
class NewPage(GtkVBox):
    def __init__(self):
	GtkVBox.__init__(self)
        self.show()

	box1 = GtkHBox()
        self.pack_start(box1)
        box1.show()

        label = GtkLabel(label='Filename: ')
        box1.pack_start(label)
        label.show()
        
        self.filename = fn = GtkEntry()
        fn.show()
        box1.pack_start(fn)

        box2 = GtkHBox()
        self.pack_start(box2)
        box2.show()
        
        label = GtkLabel(label='Title: ')
        box2.pack_start(label)
        label.show()
        
        self.title = title = GtkEntry()
        box2.pack_start(title)
        title.show()

        box3 = GtkHButtonBox()
        box3.set_layout_default(BUTTONBOX_END)
        self.pack_end(box3)
        box3.show()

        self.create = create = GtkButton(label='Create')
        create.show()
        box3.pack_end(create)
	    
    def connect(self, *args):
	apply(self.create.connect, args)
    def get_filename(self):
        return self.filename.get_text()
    def get_title(self):
        return self.title.get_text()
    def clear(self):
        self.filename.set_text('')
        self.title.set_text('')

    
class NotebookApp(GtkWindow):
    def __init__(self, pages):
        GtkWindow.__init__(self)
        self.connect('destroy', self.close)
	self.set_title('Notebook')
	self.set_border_width(5)
	self.set_usize(500, 450)

	box1 = GtkVBox()
	self.add(box1)
	box1.show()

	self.tabs = tabs = GtkNotebook()
	box1.pack_start(tabs)
	tabs.show()

        # create pages inside tabs
	for p in pages:
            self.add_tab(p)
        self.pagelist = pages

        label = GtkLabel(label='New')
        newpage = NewPage()
        newpage.connect('clicked', self.create_page, newpage)
        tabs.append_page(newpage, label)

	bbox = GtkHButtonBox()
	box1.pack_end(bbox)
	bbox.show()

	saveall = GtkButton(label='Save All')
        saveall.connect('clicked', self.save_all)
	bbox.pack_start(saveall)
	saveall.show()

	close = GtkButton(label='Close')
	close.connect('clicked', self.close)
	bbox.pack_end(close)
	close.show()

    def add_tab(self, page):
        box2 = GtkVBox()
        box2.show()

        page.set_editable(1) 
        box2.pack_start(page)
        page.show()

        bbox = GtkHButtonBox()
        box2.pack_end(bbox)
        bbox.show()

        save = GtkButton(label='Save')
        save.connect('clicked', self.save_page, page)
        bbox.pack_start(save)
        save.show()

        reload = GtkButton(label='Reload')
        reload.connect('clicked', self.reload_page, page)
        bbox.pack_start(reload)
        reload.show()

        lpr = GtkButton(label='Print')
        lpr.connect('clicked', self.print_page, page)
        bbox.pack_end(lpr)
        lpr.show()

        label = GtkLabel(page.get_title())
        # need connection here for title changes
        self.tabs.append_page(box2, label)

    def create_page(self, widget, newpage):
        filename = os.path.join(notedir, newpage.get_filename())
        title = newpage.get_title()
        p = Page(filename, title=title)
        self.add_tab(p)
        self.pagelist.append(p)

    def save_page(self, widget, page):
        page.write_file()

    def reload_page(self, widget, page):
        page.reload()

    def print_page(self, widget, page):
        page.lpr()

    def save_all(self, *args):
        for p in self.pagelist:
            p.write_file()

    def close(self, *args):
        self.destroy()
	mainquit()

    def mainloop(self):
        self.show()
	mainloop()



if __name__ == '__main__':

    if os.environ.has_key('NOTEBOOK'):
        notedir = os.environ['NOTEBOOK']
    else:
        notedir = os.path.join(os.environ['HOME'], 'Notebook')

    try:
        files = os.listdir(notedir)
	files.sort()
        pages = []

        for fn in files:
            fn = os.path.join(notedir, fn)
            if os.path.isfile(fn):
                p = Page(fn)
                pages.append(p)

	app = NotebookApp(pages)
	app.mainloop()
		
    except OSError:
        print 'No such directory %s.' % notedir

#
# end of notebook.py
#