~jaapz-b/t00mblr/trunk

#!/usr/bin/env python

#	t00mblr - a GTK tumblr client
#	By: Jaap Broekhuizen <jaapz.b@gmail.com>
#	Website: blog.jaapz.nl
#	
#	License:
#	This file is part of t00mblr.
#
#   t00mblr 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 3 of the License, or
#   (at your option) any later version.
#
#   t00mblr 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 t00mblr.  If not, see <http://www.gnu.org/licenses/>.

'''This is the preferences dialog'''

import gtk, ConfigParser

from common import d
import common as c

class c00nfig(gtk.Window):
	tabs = None
	table = None
	api = None
	
	def __init__(self, api):
		"""
			Main init
		"""
		d.debug("Creating preferences window")
		c.config = ConfigParser.SafeConfigParser()
		self.api = api
		
		gtk.Window.__init__(self)
		self.create_window()
		
	def create_window(self):
		"""
			Creates the config window
		"""
		self.set_title("t00mblr preferences")
		self.set_position(gtk.WIN_POS_CENTER)
		
		self.create_tabs()
		self.create_buttons()
		self.create_table()
		
		self.show_all()
		
	def create_tabs(self):
		"""
			Creates the tabs with their contents
		"""
		self.tabs = gtk.Notebook()
		c.get_config()
		
		# User entry
		userlabel = gtk.Label("User") # Create user page
		user = gtk.VBox() # Create user page
		user_cont1 = gtk.HBox() # Create user container
		
		user_name_label = gtk.Label("E-mail:") # Create user entry label
		user_name_label.set_size_request(125, 30)
		self.user_name = gtk.Entry() # Create user entry
		
		try:
			self.user_name.set_text(c.config.get("User","email"))
		except:
			self.user_name.set_text("")
			
		self.user_name.set_size_request(250, 30)
		user_cont1.add(user_name_label) # Add user label to container
		user_cont1.add(self.user_name) # Add user entry to container
				
		# Password entry
		user_cont2 = gtk.HBox() # Create password container
		
		pass_label = gtk.Label("Password:") # Create password entry label
		pass_label.set_size_request(125, 30)
		self.pass_entry = gtk.Entry() # Create password entry
		self.pass_entry.set_size_request(250, 30)
		
		try:
			self.pass_entry.set_text(c.get_password(c.config.get("User","blog")))
		except:
			self.pass_entry.set_text("")
		
		self.pass_entry.set_visibility(False) # Set password invisible
		user_cont2.add(pass_label) # Add password label to container
		user_cont2.add(self.pass_entry) # Add password entry to container
		
		# Blog entry
		user_cont3 = gtk.HBox() # Create blog container
		
		blog_label = gtk.Label("Blog:") # Create blog entry label
		blog_label.set_size_request(125, 30)
		self.blog_entry = gtk.Entry() # Create blog entry
		
		try:
			self.blog_entry.set_text(c.config.get("User","blog"))
		except:
			self.blog_entry.set_text("")
		
		self.blog_entry.set_size_request(250, 30)
		user_cont3.add(blog_label) # Add password blog to container
		user_cont3.add(self.blog_entry) # Add password blog to container
		
		# Remember password
		user_cont4 = gtk.HBox()
		
		self.rem_check = gtk.CheckButton("Remember password")
		self.rem_check.set_active(c.config.getboolean("User","remember"))
		user_cont4.add(self.rem_check)
		
		user.add(user_cont1) # Add username container to page
		user.add(user_cont2) # Add password container to page
		user.add(user_cont3) # Add blog container to page
		user.add(user_cont4) # Add remember password container to page
		
		# Add all pages to the notebook
		self.tabs.append_page(user, userlabel)
		
		# window page
		wpage = gtk.VBox()
		wpage_label = gtk.Label("Window")
		
		# toggle trayicon
		trayicon = gtk.HBox()
		self.trayicon_check = gtk.CheckButton("Show tray icon (needs restart)")
		self.trayicon_check.set_active(c.config.getboolean("Window","show_tray_icon"))
		trayicon.add(self.trayicon_check)
		
		wpage.add(trayicon)
		self.tabs.append_page(wpage, wpage_label)
		
		# theme page
		tpage = gtk.VBox()
		tpage_label = gtk.Label("Theme")
		
		# background color
		bg_cont = gtk.HBox()
		bg_label = gtk.Label("Background:")
		bg_label.set_size_request(250,20)
		self.bg_button = gtk.ColorButton()
		self.bg_button.set_size_request(50,25)
		
		bg_color = gtk.gdk.Color(c.config.get("Theme","background"))
		self.bg_button.set_color(bg_color)
		
		bg_cont.add(bg_label)
		bg_cont.add(self.bg_button)
		
		tpage.add(bg_cont)
		
		# foreground color
		fg_cont = gtk.HBox()
		fg_label = gtk.Label("Foreground:")
		fg_label.set_size_request(250,20)
		self.fg_button = gtk.ColorButton()
		self.fg_button.set_size_request(50,25)
		
		fg_color = gtk.gdk.Color(c.config.get("Theme","foreground"))
		self.fg_button.set_color(fg_color)
		
		fg_cont.add(fg_label)
		fg_cont.add(self.fg_button)
		
		tpage.add(fg_cont)
		
		# border color
		br_cont = gtk.HBox()
		br_label = gtk.Label("Border:")
		br_label.set_size_request(250,20)
		self.br_button = gtk.ColorButton()
		self.br_button.set_size_request(50,25)
		
		br_color = gtk.gdk.Color(c.config.get("Theme","border"))
		self.br_button.set_color(br_color)
		
		br_cont.add(br_label)
		br_cont.add(self.br_button)
		
		tpage.add(br_cont)
		
		# border size
		bs_cont = gtk.HBox()
		bs_label = gtk.Label("Border size:")
		bs_label.set_size_request(250,20)
		
		adjustment = gtk.Adjustment(value=int(c.config.get("Theme","border-size")), lower=0, upper=10, step_incr=1, page_incr=1, page_size=0)
		self.bs_count = gtk.SpinButton(adjustment, 1.0, 0)
		self.bs_count.set_range(0,10)
		self.bs_count.set_snap_to_ticks(1)
		
		bs_cont.add(bs_label)
		bs_cont.add(self.bs_count)
		
		tpage.add(bs_cont)
		
		# font color
		fc_cont = gtk.HBox(False)
		fc_label = gtk.Label("Font:")
		fc_label.set_size_request(250,20)
		self.fc_button = gtk.ColorButton()
		self.fc_button.set_size_request(50,25)
		
		fc_color = gtk.gdk.Color(c.config.get("Theme","font"))
		self.fc_button.set_color(fc_color)
		
		fc_cont.add(fc_label)
		fc_cont.add(self.fc_button)
		
		tpage.add(fc_cont)
		
		self.tabs.append_page(tpage, tpage_label)
		
	def create_buttons(self):
		"""
			Creates the save and quit buttons
		"""
		self.buttons = gtk.HButtonBox()
		self.buttons.set_layout(gtk.BUTTONBOX_END)
		
		cancel = gtk.Button(None, gtk.STOCK_CANCEL)
		cancel.connect("clicked", self.destroy_me)
		
		apply = gtk.Button(None, gtk.STOCK_APPLY)
		apply.connect("clicked", self.save_config)
		
		self.buttons.add(apply)
		self.buttons.add(cancel)
		
	def create_table(self):
		"""
			Creates the layout table
		"""
		self.table = gtk.Table(1,2,False)
		self.table.attach(self.tabs,0,1,0,1)
		self.table.attach(self.buttons,0,1,1,2, yoptions=0)
		
		self.add(self.table)
		
	def save_config(self, widget):
		"""
			Saves the config to a file
		"""
		d.debug("Saving preferences")
		
		# reload config to be sure
		c.get_config()
		
		# Get the vars we need
		blog = self.blog_entry.get_text()
		email = self.user_name.get_text()
		remember = str(self.rem_check.get_active())
		password = self.pass_entry.get_text()
		trayicon = str(self.trayicon_check.get_active())
		
		# Create clean configparser
		new_config = ConfigParser.SafeConfigParser()
		
		# Save user prefs
		new_config.add_section("User")
		new_config.set("User","email",email)
		new_config.set("User","blog",blog)
		new_config.set("User","remember",remember)
		
		# Check if password should be remembered
		if self.rem_check.get_active() == True:
			# Check whether the password is already there
			if not c.get_password(blog) or c.check_password_changed(blog, password):
				c.set_password(blog, password)
		else:
			if c.get_password(blog):
				c.remove_password()
				
		c.password = password
		self.authenticate()
			
		# Save window prefs
		new_config.add_section("Window")
		new_config.set("Window","show_tray_icon",trayicon)
		new_config.set("Window","width",c.config.get("Window","width"))
		new_config.set("Window","height",c.config.get("Window","height"))
		
		# Save theme prefs
		new_config.add_section("Theme")
		new_config.set("Theme","background",str(self.bg_button.get_color()))
		new_config.set("Theme","foreground",str(self.fg_button.get_color()))
		new_config.set("Theme","border",str(self.br_button.get_color()))
		new_config.set("Theme","font",str(self.fc_button.get_color()))
		new_config.set("Theme","border-size",str(self.bs_count.get_value_as_int()))
			
		# Save config
		file = open(c.config_path, "wb")
		new_config.write(file)
		file.close()
		
		# Close the preferences window
		self.destroy_me()
		
	def authenticate(self):
		"""
			Gets called after password has been set
		"""
		try:
			self.api = c.authenticate(self.api, c.password)
			c.update_viewer()
		except:
			d.error("Authentication gone wrong!")
		
	def destroy_me(self, widget=None):
		"""
			Destroys the configuration window
		"""
		d.debug("Destroying preferences window")
		c.update_viewer()
		self.destroy()