root / pykoticon / trunk / bin / pykoticon @ 92

#! /usr/bin/env python
# -*- coding: ISO-8859-15 -*-

# PyKotIcon - Client side helper for PyKota
#
# (c) 2003, 2004, 2005, 2006 Jerome Alet <alet@librelogiciel.com>
# 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
#
# $Id$
#
#

import sys
import os
import urllib
import urllib2
import locale
import gettext
import socket
import threading
import xmlrpclib
import SimpleXMLRPCServer

import time

if sys.platform == "win32" :
    isWindows = 1
    try :
        import win32api
    except ImportError :    
        raise ImportError, "Mark Hammond's Win32 Extensions are missing. Please install them."
    else :    
        iconsdir = os.path.split(sys.argv[0])[0]
else :        
    isWindows = 0
    iconsdir = "/usr/share/pykoticon"   # TODO : change this
    import pwd
    
try :    
    import wxPython.wx
    import wx
    hasWxPython = 1
except ImportError :    
    hasWxPython = 0
    raise ImportError, "wxPython is missing. Please install it."
    
def getCurrentUserName() :
    """Retrieves the current user's name."""
    if isWindows :
        return win32api.GetUserName()
    else :    
        try :
            return pwd.getpwuid(os.geteuid())[0]
        except :
            return "** Unknown **"
        
class MyXMLRPCServer(SimpleXMLRPCServer.SimpleXMLRPCServer) :
    """My own server class."""
    allow_reuse_address = True
    def __init__(self, frame, printserver, localport, debug=False) :
        SimpleXMLRPCServer.SimpleXMLRPCServer.__init__(self, ('0.0.0.0', localport))
        self.printServer = printserver
        self.frame = frame
        self.debug = debug
        loop = threading.Thread(target=self.mainloop)
        loop.start()
        
    def logDebug(self, message) :    
        """Logs a debug message if debug mode is active."""
        if self.debug :
            sys.stderr.write("%s\n" % message)
            
    def export_quitApplication(self) :    
        """Makes the application quit."""
        self.logDebug("Remote host asked to close the application.")
        self.frame.quitEvent.set()
        wx.CallAfter(self.frame.OnClose, None)
        return True
        
    def export_openConfirmDialog(self, printername, username, jobid, jobtitle, jobsize) :    
        """Opens a dialog to ask the user to confirm or cancel the print job.
        
           Returns True to confirm, False to cancel.
        """   
        wx.CallAfter(self.frame.askConfirmation, printername, username, jobid, jobtitle, jobsize)
        
        # ugly, isn't it ?
        while self.frame.askConfirmationResult is None :
            time.sleep(0.5)
        retcode = self.frame.askConfirmationResult    
        self.frame.askConfirmationResult = None # prepare for next call, just in case
        return retcode
        
    def export_nop(self) :    
        """Does nothing, but allows a clean shutdown from the frame itself."""
        self.logDebug("No operation !")
        return True
        
    def verify_request(self, request, client_address) :
        """Ensures that requests which don't come from the print server are rejected."""
        (client, port) = client_address
        if socket.gethostbyname(self.printServer) == client :
            self.logDebug("%s accepted." % client)
            return True
        else :
            # Unauthorized access !
            self.logDebug("%s rejected." % client)
            return False
        
    def _dispatch(self, method, params) :    
        """Ensure that only export_* methods are available."""
        return getattr(self, "export_%s" % method)(*params)
        
    def mainloop(self) :
        """XML-RPC Server's main loop."""
        self.register_function(self.export_openConfirmDialog)
        self.register_function(self.export_quitApplication)
        self.register_function(self.export_nop)
        while not self.frame.quitEvent.isSet() :
            self.handle_request()
        self.server_close()    
        sys.exit(0)
    
class PyKotIcon(wx.Frame):
    """Main class."""
    def __init__(self, parent, id):
        self.askConfirmationResult = None
        wx.Frame.__init__(self, parent, wx.ID_ANY, \
               _("PyKota info for  %s") % getCurrentUserName(), \
               size = (-1, -1), \
               style = wxPython.wx.wxDEFAULT_FRAME_STYLE \
                     | wxPython.wx.wxSIZE_AUTO_HEIGHT \
                     | wxPython.wx.wxSIZE_AUTO_WIDTH \
                     | wxPython.wx.wxNO_FULL_REPAINT_ON_RESIZE)
#        try :             
#            self.tbicon = wxPython.wx.wxTaskBarIcon()
#        except AttributeError :    
#            self.tbicon = None # No taskbar icon facility, old wxWidgets maybe
#        
#        self.greenicon = wxPython.wx.wxIcon(os.path.join(iconsdir, "pykoticon-green.ico"), \
#                                  wxPython.wx.wxBITMAP_TYPE_ICO)
#        self.redicon = wxPython.wx.wxIcon(os.path.join(iconsdir, "pykoticon-red.ico"), \
#                                  wxPython.wx.wxBITMAP_TYPE_ICO)
#        
#        self.SetIcon(self.greenicon)
#        if self.tbicon is not None :
#            self.tbicon.SetIcon(self.greenicon, "PyKotIcon")
#            wxPython.wx.EVT_TASKBAR_LEFT_DCLICK(self.tbicon, self.OnTaskBarActivate)
#            wxPython.wx.EVT_TASKBAR_RIGHT_UP(self.tbicon, self.OnTaskBarMenu)
#        
#            self.TBMENU_RESTORE = wx.NewId()
#            self.TBMENU_CLOSE = wx.NewId()
#            wxPython.wx.EVT_MENU(self.tbicon, self.TBMENU_RESTORE, \
#                                              self.OnTaskBarActivate)
#            wxPython.wx.EVT_MENU(self.tbicon, self.TBMENU_CLOSE, \
#                                              self.OnTaskBarClose)
#            self.menu = wxPython.wx.wxMenu()
#            self.menu.Append(self.TBMENU_RESTORE, _("Show Print Quota"))
#            self.menu.Append(self.TBMENU_CLOSE, _("Quit"))
#        
        wxPython.wx.EVT_ICONIZE(self, self.OnIconify)
        wxPython.wx.EVT_CLOSE(self, self.OnClose)
        self.Show(True)
        
    def closeServer(self) :    
        """Tells the xml-rpc server to exit."""
        if not self.quitEvent.isSet() :
            self.quitEvent.set()
        server = xmlrpclib.ServerProxy("http://localhost:%s" % self.port)    
        try :
            # wake the server with an empty request 
            # for it to see the event object
            # which has just been set
            server.nop()
        except :    
            # Probably already stopped
            pass
        
    def postInit(self, printserver, localport) :    
        """Starts the XML-RPC server."""
        self.quitEvent = threading.Event()
        self.port = localport
        self.server = MyXMLRPCServer(self, printserver, localport, debug=True)
    
    def OnIconify(self, event) :
        self.Hide()

    def OnTaskBarActivate(self, event) :
        #if self.IsIconized() :
        #    self.Iconize(False)
        if not self.IsShown() :
            self.Show(True)
        self.Raise()

    def OnClose(self, event) :
        sys.stderr.write("Close event !\n")
        self.closeServer()
        if hasattr(self, "menu") :
            self.menu.Destroy()
            del self.menu
        if hasattr(self, "tbicon") and self.tbicon :
            self.tbicon.Destroy()
            del self.tbicon
        self.Destroy()

    def OnTaskBarMenu(self, event) :
        #if self.tbicon :
        #    self.tbicon.PopupMenu(self.menu)
        pass

    def OnTaskBarClose(self, event) :
        self.Close()
        
    def askConfirmation(self, printername, username, jobid, jobtitle, jobsize) :
        """Asks for confirmation before printing."""
        message = _("""Hello %(username)s,
        
You sent job %(jobid)s (%(jobtitle)s) to printer %(printername)s.

This job seems to be %(jobsize)s pages long. 

Please confirm or cancel.""") % locals()
                     
        dialog = wx.MessageDialog(self, message, _("Confirmation"), wx.OK | wx.CANCEL)
        self.askConfirmationResult = dialog.ShowModal()
        dialog.Destroy()

class PyKotIconApp(wx.PySimpleApp):
    def OnInit(self) :
        self.frame = PyKotIcon(None, -1)
        return True
        
    def postInit(self, printserver, localport) :    
        """Continues processing."""
        self.frame.postInit(printserver, localport)
        self.frame.Show(True)
        
def main(printserver, localport):
    """Program's entry point."""
    try :
        locale.setlocale(locale.LC_ALL, "")
    except (locale.Error, IOError) :
        sys.stderr.write("Problem while setting locale.\n")
    try :
        gettext.install("pykoticon")
    except :
        gettext.NullTranslations().install()
    app = PyKotIconApp()
    try :
        localport = int(localport)    
    except (TypeError, ValueError) :    
        raise ValueError, "Invalid TCP port parameter %s\n" % localport
    app.postInit(printserver, localport)
    app.MainLoop()
    
def crashed() :    
    """Minimal crash method."""
    import traceback
    lines = []
    for line in traceback.format_exception(*sys.exc_info()) :
        lines.extend([l for l in line.split("\n") if l])
    msg = "ERROR: ".join(["%s\n" % l for l in (["ERROR: PyKotIcon"] + lines)])
    sys.stderr.write(msg)
    sys.stderr.flush()
    
if __name__ == '__main__':
    if len(sys.argv) >= 2 :
        arg = sys.argv[1]
        if arg in ("-v", "--version") :    
            print "0.3"
        elif arg in ("-h", "--help") :    
            print "usage : pykoticon printserver_hostname localport"
        else :
            main(*sys.argv[1:3])
    else :    
        main("localhost", "7654")