home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / share / hplip / fab.py < prev    next >
Encoding:
Python Source  |  2008-10-13  |  24.7 KB  |  916 lines
  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. #
  4. # (c) Copyright 2003-2007 Hewlett-Packard Development Company, L.P.
  5. #
  6. # This program is free software; you can redistribute it and/or modify
  7. # it under the terms of the GNU General Public License as published by
  8. # the Free Software Foundation; either version 2 of the License, or
  9. # (at your option) any later version.
  10. #
  11. # This program is distributed in the hope that it will be useful,
  12. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. # GNU General Public License for more details.
  15. #
  16. # You should have received a copy of the GNU General Public License
  17. # along with this program; if not, write to the Free Software
  18. # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19. #
  20. # Author: Don Welch
  21. #
  22.  
  23. __version__ = '4.1'
  24. __title__ = "Fax Address Book"
  25. __doc__ = "A simple fax address book for HPLIP."
  26.  
  27. # Std Lib
  28. import cmd
  29. import getopt
  30. import os
  31.  
  32. # Local
  33. from base.g import *
  34. from base import utils, tui
  35.  
  36.  
  37. log.set_module("hp-fab")
  38.  
  39.  
  40. USAGE = [(__doc__, "", "name", True),
  41.          ("Usage: hp-fab [MODE] [OPTIONS]", "", "summary", True),
  42.          ("[MODE]", "", "header", False),
  43.          ("Enter interactive mode:", "-i or --interactive (see Note 1)", "option", False),
  44.          ("Enter graphical UI mode:", "-u or --gui (Default)", "option", False),
  45.          utils.USAGE_SPACE,
  46.          utils.USAGE_OPTIONS,
  47.          utils.USAGE_LANGUAGE,
  48.          utils.USAGE_LOGGING1, utils.USAGE_LOGGING2, utils.USAGE_LOGGING3,
  49.          utils.USAGE_HELP,
  50.          utils.USAGE_NOTES,
  51.          ("1. Use 'help' command at the fab > prompt for command help (interactive mode (-i) only).", "", "note", False),
  52.          utils.USAGE_SPACE,
  53.          utils.USAGE_SEEALSO,
  54.          ("hp-sendfax", "", "seealso", False),
  55.          ]
  56.  
  57. def usage(typ='text'):
  58.     if typ == 'text':
  59.         utils.log_title(__title__, __version__)
  60.  
  61.     utils.format_text(USAGE, typ, __title__, 'hp-fab', __version__)
  62.     sys.exit(0)
  63.  
  64.  
  65. # Console class (from ASPN Python Cookbook)
  66. # Author:   James Thiele
  67. # Date:     27 April 2004
  68. # Version:  1.0
  69. # Location: http://www.eskimo.com/~jet/python/examples/cmd/
  70. # Copyright (c) 2004, James Thiele
  71. class Console(cmd.Cmd):
  72.  
  73.     def __init__(self):
  74.         cmd.Cmd.__init__(self)
  75.         self.intro  = "Type 'help' for a list of commands. Type 'exit' or 'quit' to quit."
  76.         self.db =  fax.FaxAddressBook() # database instance
  77.         self.prompt = log.bold("hp-fab > ")
  78.  
  79.     # Command definitions
  80.     def do_hist(self, args):
  81.         """Print a list of commands that have been entered"""
  82.         print self._hist
  83.  
  84.     def do_exit(self, args):
  85.         """Exits from the console"""
  86.         return -1
  87.  
  88.     def do_quit(self, args):
  89.         """Exits from the console"""
  90.         return -1
  91.  
  92.     # Command definitions to support Cmd object functionality
  93.     def do_EOF(self, args):
  94.         """Exit on system end of file character"""
  95.         return self.do_exit(args)
  96.  
  97.     def do_help(self, args):
  98.         """Get help on commands
  99.            'help' or '?' with no arguments prints a list of commands for which help is available
  100.            'help <command>' or '? <command>' gives help on <command>
  101.         """
  102.         # The only reason to define this method is for the help text in the doc string
  103.         cmd.Cmd.do_help(self, args)
  104.  
  105.     # Override methods in Cmd object
  106.     def preloop(self):
  107.         """Initialization before prompting user for commands.
  108.            Despite the claims in the Cmd documentaion, Cmd.preloop() is not a stub.
  109.         """
  110.         cmd.Cmd.preloop(self)   # sets up command completion
  111.         self._hist    = []      # No history yet
  112.         self._locals  = {}      # Initialize execution namespace for user
  113.         self._globals = {}
  114.  
  115.         self.do_list('')
  116.  
  117.     def postloop(self):
  118.         """Take care of any unfinished business.
  119.            Despite the claims in the Cmd documentaion, Cmd.postloop() is not a stub.
  120.         """
  121.         cmd.Cmd.postloop(self)   # Clean up command completion
  122.         print "Exiting..."
  123.  
  124.     def precmd(self, line):
  125.         """ This method is called after the line has been input but before
  126.             it has been interpreted. If you want to modifdy the input line
  127.             before execution (for example, variable substitution) do it here.
  128.         """
  129.         self._hist += [line.strip()]
  130.         return line
  131.  
  132.     def postcmd(self, stop, line):
  133.         """If you want to stop the console, return something that evaluates to true.
  134.            If you want to do some post command processing, do it here.
  135.         """
  136.         return stop
  137.  
  138.     def emptyline(self):
  139.         """Do nothing on empty input line"""
  140.         pass
  141.  
  142.     def default(self, line):
  143.         log.error("Unrecognized command. Use 'help' to list commands.")
  144.  
  145.     def get_nickname(self, args, fail_if_match=True, alt_text=False):
  146.         if not args:
  147.             while True:
  148.                 if alt_text:
  149.                     nickname = raw_input(log.bold("Enter the name (nickname) to add (<enter>=done*, c=cancel) ? ")).strip()
  150.                 else:
  151.                     nickname = raw_input(log.bold("Enter the name (nickname) (c=cancel) ? ")).strip()
  152.  
  153.                 if nickname.lower() == 'c':
  154.                     print log.red("Canceled")
  155.                     return ''
  156.  
  157.                 if not nickname:
  158.                     if alt_text:
  159.                         return ''
  160.                     else:
  161.                         log.error("Nickname must not be blank.")
  162.                         continue
  163.  
  164.  
  165.                 if fail_if_match:
  166.                     if self.db.get(nickname) is not None:
  167.                         log.error("Name already exists. Please choose a different name.")
  168.                         continue
  169.  
  170.                 else:
  171.                     if self.db.get(nickname) is None:
  172.                         log.error("Name not found. Please enter a different name.")
  173.                         continue
  174.  
  175.                 break
  176.  
  177.         else:
  178.             nickname = args.strip()
  179.  
  180.             if fail_if_match:
  181.                 if self.db.get(nickname) is not None:
  182.                     log.error("Name already exists. Please choose a different name.")
  183.                     return ''
  184.  
  185.             else:
  186.                 if self.db.get(nickname) is None:
  187.                     log.error("Name not found. Please enter a different name.")
  188.                     return ''
  189.  
  190.         return nickname
  191.  
  192.  
  193.     def get_groupname(self, args, fail_if_match=True, alt_text=False):
  194.         all_groups = self.db.get_all_groups()
  195.  
  196.         if not args:
  197.             while True:
  198.                 if alt_text:
  199.                     groupname = raw_input(log.bold("Enter the group name to join (<enter>=done*, c=cancel) ? ")).strip()
  200.                 else:
  201.                     groupname = raw_input(log.bold("Enter the group name (c=cancel) ? ")).strip()
  202.  
  203.  
  204.                 if groupname.lower() == 'c':
  205.                     print log.red("Canceled")
  206.                     return ''
  207.  
  208.                 if not groupname:
  209.                     if alt_text:
  210.                         return ''
  211.                     else:
  212.                         log.error("The group name must not be blank.")
  213.                         continue
  214.  
  215.                 if fail_if_match: 
  216.                     if groupname in all_groups:
  217.                         log.error("Name already exists. Please choose a different name.")
  218.                         continue
  219.  
  220.                 else:
  221.                     if groupname not in all_groups:
  222.                         log.error("Name not found. Please enter a different name.")
  223.                         continue
  224.  
  225.                 break
  226.  
  227.         else:
  228.             groupname = args.strip()
  229.  
  230.             if fail_if_match: 
  231.                 if groupname in all_groups:
  232.                     log.error("Name already exists. Please choose a different name.")
  233.                     return ''
  234.  
  235.             else:
  236.                 if groupname not in all_groups:
  237.                     log.error("Name not found. Please enter a different name.")
  238.                     return ''
  239.  
  240.         return groupname
  241.  
  242.     def do_list(self, args):
  243.         """ 
  244.         List names and/or groups.
  245.         list [names|groups|all|]
  246.         dir [names|groups|all|]
  247.         """
  248.  
  249.         if args:
  250.             scope = args.strip().split()[0]
  251.  
  252.             if args.startswith('nam'):
  253.                 self.do_names('')
  254.                 return
  255.  
  256.             elif args.startswith('gro'):
  257.                 self.do_groups('')
  258.                 return
  259.  
  260.         self.do_names('')
  261.         self.do_groups('')
  262.  
  263.     do_dir = do_list
  264.  
  265.     def do_names(self, args):
  266.         """
  267.         List names.
  268.         names
  269.         """
  270.         all_entries = self.db.get_all_records()
  271.         log.debug(all_entries)
  272.  
  273.         print log.bold("\nNames:\n")
  274.         if len(all_entries) > 0:
  275.  
  276.             f = tui.Formatter()
  277.             f.header = ("Name", "Fax Number", "Member of Group(s)")
  278.             for name, e in all_entries.items():
  279.                 f.add((name, e['fax'], ', '.join(e['groups'])))
  280.  
  281.             f.output()
  282.  
  283.         else:
  284.             print "(None)"
  285.  
  286.         print
  287.  
  288.     def do_groups(self, args):
  289.         """ 
  290.         List groups.
  291.         groups
  292.         """
  293.         #all_groups = self.db.AllGroups() XXXXXXXXXXXXXX
  294.         all_groups = self.db.get_all_groups()
  295.         log.debug(all_groups)
  296.  
  297.         print log.bold("\nGroups:\n")
  298.         if len(all_groups):
  299.  
  300.             f = tui.Formatter()
  301.             f.header = ("Group", "Members")
  302.             for group in all_groups:
  303.                 f.add((group, ', '.join(self.db.group_members(group))))
  304.             f.output()
  305.  
  306.         else:
  307.             print "(None)"
  308.  
  309.         print
  310.  
  311.  
  312.     def do_edit(self, args):
  313.         """
  314.         Edit an name.
  315.         edit [name]
  316.         modify [name]
  317.         """
  318.         nickname = self.get_nickname(args, fail_if_match=False)
  319.         if not nickname: return
  320.  
  321.         e = self.db.get(nickname)
  322.         log.debug(e)
  323.  
  324.         print log.bold("\nEdit/modify information for %s:\n" % nickname)
  325.  
  326.         save_title = e['title']
  327.         title = raw_input(log.bold("Title (<enter>='%s', c=cancel)? " % save_title)).strip()
  328.  
  329.         if title.lower() == 'c':
  330.             print log.red("Canceled")
  331.             return
  332.  
  333.         if not title:
  334.             title = save_title
  335.  
  336.         save_firstname = e['firstname']
  337.         firstname = raw_input(log.bold("First name (<enter>='%s', c=cancel)? " % save_firstname)).strip()
  338.  
  339.         if firstname.lower() == 'c':
  340.             print log.red("Canceled")
  341.             return
  342.  
  343.         if not firstname:
  344.             firstname = save_firstname
  345.  
  346.         save_lastname = e['lastname']
  347.         lastname = raw_input(log.bold("Last name (<enter>='%s', c=cancel)? " % save_lastname)).strip()
  348.  
  349.         if lastname.lower() == 'c':
  350.             print log.red("Canceled")
  351.             return
  352.  
  353.         if not lastname:
  354.             lastname = save_lastname
  355.  
  356.         save_faxnum = e['fax']
  357.         while True:
  358.             faxnum = raw_input(log.bold("Fax Number (<enter>='%s', c=cancel)? " % save_faxnum)).strip()
  359.  
  360.             if faxnum.lower() == 'c':
  361.                 print log.red("Canceled")
  362.                 return
  363.  
  364.             if not faxnum and not save_faxnum:
  365.                 log.error("Fax number must not be empty.")
  366.                 continue
  367.  
  368.             if not faxnum:
  369.                 faxnum = save_faxnum
  370.  
  371.             ok = True
  372.             for c in faxnum:
  373.                 if c not in '0123456789-(+) *#':
  374.                     log.error("Invalid characters in fax number. Fax number may only contain '0123456789-(+) '")
  375.                     ok = False
  376.                     break
  377.  
  378.  
  379.             if ok: break
  380.  
  381.         save_notes = e['notes']
  382.         notes = raw_input(log.bold("Notes (<enter>='%s', c=cancel)? " % save_notes)).strip()
  383.  
  384.         if notes.lower() == 'c':
  385.             print log.red("Canceled")
  386.             return
  387.  
  388.         if not notes:
  389.             notes = save_notes
  390.  
  391.         if e['groups']:
  392.             print "\nLeave or Stay in a Group:\n"
  393.  
  394.         new_groups = []
  395.         for g in e['groups']:
  396.             ok, ans = tui.enter_yes_no("Stay in group %s" % g, 
  397.                 choice_prompt="(y=yes* (stay), n=no (leave), c=cancel)")
  398.  
  399.             if not ok:
  400.                 print log.red("Canceled")
  401.                 return
  402.  
  403.             if ans:
  404.                 new_groups.append(g)
  405.  
  406.         print "\nJoin New Group(s):\n"
  407.  
  408.         while True:
  409.             add_group = self.get_groupname('', fail_if_match=False, alt_text=True) 
  410.  
  411.             if add_group.lower() == 'c':
  412.                 print log.red("Canceled")
  413.                 return
  414.  
  415.             if not add_group.lower():
  416.                 break
  417.  
  418.             get_all_groups = self.db.get_all_groups()
  419.  
  420.             if add_group not in all_groups:
  421.                 log.warn("Group not found.")
  422.                 ok, ans = tui.enter_yes_no("Is this a new group", 
  423.                     choice_prompt="(y=yes* (new), n=no, c=cancel)")
  424.  
  425.                 if not ok:
  426.                     print log.red("Canceled")
  427.                     return
  428.  
  429.                 if not ans:
  430.                     continue
  431.  
  432.             if add_group in e['groups']:
  433.                 log.error("Group already specified. Choose a different group name or press <enter> to continue.")
  434.                 continue
  435.  
  436.             new_groups.append(add_group)
  437.  
  438.  
  439.         self.db.set(nickname, title, firstname, lastname, faxnum, new_groups, notes)
  440.         self.do_show(nickname)
  441.  
  442.         print
  443.  
  444.     do_modify = do_edit
  445.  
  446.  
  447.     def do_editgrp(self, args):
  448.         """
  449.         Edit a group.
  450.         editgrp [group]
  451.         modifygrp [group]
  452.         """
  453.         group = self.get_groupname(args, fail_if_match=False)
  454.         if not group: return
  455.  
  456.         old_entries = self.db.group_members(group)
  457.  
  458.         new_entries = []
  459.  
  460.         print "\nLeave or Remove Existing Names in Group:\n"
  461.  
  462.         for e in old_entries:
  463.  
  464.             ok, ans = tui.enter_yes_no("Leave name '%s' in this group" % e, 
  465.                 choice_prompt="(y=yes* (leave), n=no (remove), c=cancel)")
  466.  
  467.             if not ok:
  468.                 print log.red("Canceled")
  469.                 return
  470.  
  471.             if ans:
  472.                 new_entries.append(e)
  473.  
  474.         print "\nAdd New Names in Group:\n"
  475.  
  476.         while True:
  477.             nickname = self.get_nickname('', fail_if_match=False, alt_text=True)
  478.  
  479.             if nickname.lower() == 'c':
  480.                 print log.red("Canceled")
  481.                 return
  482.  
  483.             if not nickname.lower():
  484.                 break
  485.  
  486.             new_entries.append(nickname)
  487.  
  488.         self.db.update_groups(group, new_entries)
  489.  
  490.         print
  491.  
  492.     do_modifygrp = do_editgrp
  493.  
  494.  
  495.     def do_add(self, args):
  496.         """
  497.         Add an name.
  498.         add [name]
  499.         new [name]
  500.         """
  501.         nickname = self.get_nickname(args, fail_if_match=True)
  502.         if not nickname: return
  503.  
  504.         print log.bold("\nEnter information for %s:\n" % nickname)
  505.  
  506.         title = raw_input(log.bold("Title (c=cancel)? ")).strip()
  507.  
  508.         if title.lower() == 'c':
  509.             print log.red("Canceled")
  510.             return
  511.  
  512.         firstname = raw_input(log.bold("First name (c=cancel)? ")).strip()
  513.  
  514.         if firstname.lower() == 'c':
  515.             print log.red("Canceled")
  516.             return
  517.  
  518.         lastname = raw_input(log.bold("Last name (c=cancel)? ")).strip()
  519.  
  520.         if lastname.lower() == 'c':
  521.             print log.red("Canceled")
  522.             return
  523.  
  524.         while True:
  525.             faxnum = raw_input(log.bold("Fax Number (c=cancel)? ")).strip()
  526.  
  527.             if faxnum.lower() == 'c':
  528.                 print log.red("Canceled")
  529.                 return
  530.  
  531.             if not faxnum:
  532.                 log.error("Fax number must not be empty.")
  533.                 continue
  534.  
  535.             ok = True
  536.             for c in faxnum:
  537.                 if c not in '0123456789-(+) *#':
  538.                     log.error("Invalid characters in fax number. Fax number may only contain '0123456789-(+) *#'")
  539.                     ok = False
  540.                     break
  541.  
  542.  
  543.             if ok: break
  544.  
  545.         notes = raw_input(log.bold("Notes (c=cancel)? ")).strip()
  546.  
  547.         if notes.strip().lower() == 'c':
  548.             print log.red("Canceled")
  549.             return
  550.  
  551.         groups = []
  552.         all_groups = self.db.get_all_groups()
  553.         while True:
  554.             add_group = raw_input(log.bold("Member of group (<enter>=done*, c=cancel) ?" )).strip()
  555.  
  556.             if add_group.lower() == 'c':
  557.                 print log.red("Canceled")
  558.                 return
  559.  
  560.             if not add_group:
  561.                 break
  562.  
  563.             if add_group not in all_groups:
  564.                 log.warn("Group not found.")
  565.  
  566.                 while True:
  567.                     user_input = raw_input(log.bold("Is this a new group (y=yes*, n=no) ?")).lower().strip()
  568.  
  569.                     if user_input not in ['', 'n', 'y']:
  570.                         log.error("Please enter 'y', 'n' or press <enter> for 'yes'.")
  571.                         continue
  572.  
  573.                     break
  574.  
  575.                 if user_input == 'n':
  576.                     continue
  577.  
  578.             if add_group in groups:
  579.                 log.error("Group already specified. Choose a different group name or press <enter> to continue.")
  580.                 continue
  581.  
  582.             groups.append(add_group)
  583.  
  584.         self.db.set(nickname, title, firstname, lastname, faxnum, groups, notes)
  585.         self.do_show(nickname)
  586.  
  587.  
  588.     do_new = do_add
  589.  
  590.  
  591.     def do_addgrp(self, args):
  592.         """
  593.         Add a group.
  594.         addgrp [group]
  595.         newgrp [group]
  596.         """
  597.         group = self.get_groupname(args, fail_if_match=True)
  598.         if not group: return
  599.  
  600.         entries = []
  601.         while True:
  602.             nickname = self.get_nickname('', fail_if_match=False, alt_text=True)
  603.  
  604.             if nickname.lower() == 'c':
  605.                 print log.red("Canceled")
  606.                 return
  607.  
  608.             if not nickname.lower():
  609.                 break
  610.  
  611.             entries.append(nickname)
  612.  
  613.         self.db.update_groups(group, entries)
  614.  
  615.         print
  616.  
  617.     do_newgrp = do_addgrp
  618.  
  619.  
  620.     def do_view(self, args):
  621.         """
  622.         View all name data.
  623.         view
  624.         """
  625.         all_entries = self.db.get_all_records()
  626.         log.debug(all_entries)
  627.  
  628.         print log.bold("\nView all Data:\n")
  629.         if len(all_entries) > 0:
  630.  
  631.             f = tui.Formatter()
  632.             f.header = ("Name", "Title", "First Name", "Last Name", "Fax", "Notes", "Member of Group(s)")
  633.  
  634.             for name, e in all_entries.items():
  635.                 f.add((name, e['title'], e['firstname'], e['lastname'], e['fax'], 
  636.                        e['notes'], ', '.join(e['groups'])))
  637.  
  638.             f.output()
  639.  
  640.         print
  641.  
  642.  
  643.  
  644.     def do_show(self, args):
  645.         """
  646.         Show a name (all details).
  647.         show [name]
  648.         details [name]
  649.         """
  650.         name = self.get_nickname(args, fail_if_match=False)
  651.         if not name: return
  652.  
  653.         e = self.db.get(name)
  654.         if e:
  655.             f = tui.Formatter()
  656.             f.header = ("Key", "Value")
  657.             f.add(("Name:", name))
  658.             f.add(("Title:", e['title']))
  659.             f.add(("First Name:", e['firstname']))
  660.             f.add(("Last Name:", e['lastname']))
  661.             f.add(("Fax Number:", e['fax']))
  662.             f.add(("Notes:", e['notes']))
  663.             f.add(("Member of Group(s):", ', '.join(e['groups'])))
  664.  
  665.             f.output()
  666.  
  667.         else:
  668.             log.error("Name not found. Use the 'names' command to view all names.")
  669.  
  670.         print
  671.  
  672.     do_details = do_show
  673.  
  674.     def do_rm(self, args):
  675.         """
  676.         Remove a name.
  677.         rm [name]
  678.         del [name]
  679.         """
  680.         nickname = self.get_nickname(args, fail_if_match=False)
  681.         if not nickname: return
  682.  
  683.         self.db.delete(nickname)
  684.  
  685.         print
  686.  
  687.     do_del = do_rm
  688.  
  689.     def do_rmgrp(self, args):
  690.         """
  691.         Remove a group.
  692.         rmgrp [group]
  693.         delgrp [group]
  694.         """
  695.         group = self.get_groupname(args, fail_if_match=False)
  696.         if not group: return
  697.  
  698.         self.db.delete_group(group)
  699.  
  700.         print
  701.  
  702.     do_delgrp = do_rmgrp
  703.  
  704.  
  705.     def do_about(self, args):
  706.         """About fab."""
  707.         utils.log_title(__title__, __version__)
  708.  
  709.     def do_import(self, args):
  710.         """ 
  711.         Import LDIF
  712.         import <filename> [type]
  713.         [type] = vcf|ldif|auto
  714.         """
  715.         args = args.strip().split()
  716.  
  717.         if not args:
  718.             log.error("You must specify a filename to import from.")
  719.             return
  720.  
  721.         filename = args[0]
  722.  
  723.         if len(args) > 1:
  724.             typ = args[1].lower()
  725.         else:
  726.             typ = 'auto'
  727.  
  728.         if typ not in ('auto', 'ldif', 'vcf', 'vcard'):
  729.             log.error("Invalid type: %s" % typ)
  730.             return
  731.  
  732.         if not os.path.exists(filename):
  733.             log.error("File %s not found." % filename)
  734.             return
  735.  
  736.         if typ == 'auto':
  737.             ext = os.path.splitext(filename)[1].lower()
  738.             if ext == '.vcf':
  739.                 typ = 'vcf'
  740.             elif ext == '.ldif':
  741.                 typ = 'ldif'
  742.             else:
  743.                 head = file(filename, 'r').read(1024).lower()
  744.                 if 'begin:vcard' in head:
  745.                     typ = 'vcf'
  746.                 else:
  747.                     typ = 'ldif'
  748.  
  749.         if typ == 'ldif':
  750.             print "Importing from LDIF file %s..." % filename
  751.             ok, error_str = self.db.import_ldif(filename)
  752.  
  753.         elif typ in ('vcard', 'vcf'):
  754.             print "Importing from VCF file %s..." % filename
  755.             ok, error_str = self.db.import_vcard(filename)
  756.  
  757.         if not ok:
  758.             log.error(error_str)
  759.         else:
  760.             self.db.save()
  761.             self.do_list('')
  762.  
  763.         print
  764.  
  765.  
  766.  
  767. mode = GUI_MODE
  768. mode_specified = False
  769. loc = None
  770.  
  771. try:
  772.     opts, args = getopt.getopt(sys.argv[1:], 'l:hgiuq:', 
  773.         ['level=', 'help', 'help-rest', 'help-man',
  774.          'help-desc', 'gui', 'interactive', 'lang='])
  775.  
  776. except getopt.GetoptError, e:
  777.     log.error(e.msg)
  778.     usage()
  779.  
  780. if os.getenv("HPLIP_DEBUG"):
  781.     log.set_level('debug')
  782.  
  783. for o, a in opts:
  784.     if o in ('-l', '--logging'):
  785.         log_level = a.lower().strip()
  786.         if not log.set_level(log_level):
  787.             usage()
  788.  
  789.     elif o == '-g':
  790.         log.set_level('debug')
  791.  
  792.     elif o in ('-h', '--help'):
  793.         usage()
  794.  
  795.     elif o == '--help-rest':
  796.         usage('rest')
  797.  
  798.     elif o == '--help-man':
  799.         usage('man')
  800.  
  801.     elif o == '--help-desc':
  802.         print __doc__,
  803.         sys.exit(0)
  804.  
  805.     elif o in ('-i', '--interactive'):
  806.         if mode_specified:
  807.             log.error("You may only specify a single mode as a parameter (-i or -u).")
  808.             sys.exit(1)
  809.  
  810.         mode = INTERACTIVE_MODE
  811.         mode_specified = True
  812.  
  813.     elif o in ('-u', '--gui'):
  814.         if mode_specified:
  815.             log.error("You may only specify a single mode as a parameter (-i or -u).")
  816.             sys.exit(1)
  817.  
  818.         mode = GUI_MODE
  819.         mode_specified = True
  820.  
  821.     elif o in ('-q', '--lang'):
  822.         if a.strip() == '?':
  823.             tui.show_languages()
  824.             sys.exit(0)
  825.  
  826.         loc = utils.validate_language(a.lower())        
  827.  
  828. utils.log_title(__title__, __version__)
  829.  
  830. if os.getuid() == 0:
  831.     log.warn("hp-fab should not be run as root.")
  832.  
  833. # Security: Do *not* create files that other users can muck around with
  834. os.umask(0037)
  835.  
  836. if mode == GUI_MODE:
  837.     if not utils.canEnterGUIMode():
  838.         mode = NON_INTERACTIVE_MODE
  839.  
  840. if mode == GUI_MODE:
  841.     from qt import *
  842.     from ui.faxaddrbookform import FaxAddrBookForm
  843.  
  844.     app = None
  845.     addrbook = None
  846.     # create the main application object
  847.     app = QApplication(sys.argv)
  848.  
  849.     if loc is None:
  850.         loc = user_cfg.ui.get("loc", "system")
  851.         if loc.lower() == 'system':
  852.             loc = str(QTextCodec.locale())
  853.             log.debug("Using system locale: %s" % loc)
  854.  
  855.     if loc.lower() != 'c':
  856.         e = 'utf8'
  857.         try:
  858.             l, x = loc.split('.')
  859.             loc = '.'.join([l, e])
  860.         except ValueError:
  861.             l = loc
  862.             loc = '.'.join([loc, e])
  863.  
  864.         log.debug("Trying to load .qm file for %s locale." % loc)
  865.         trans = QTranslator(None)
  866.  
  867.         qm_file = 'hplip_%s.qm' % l
  868.         log.debug("Name of .qm file: %s" % qm_file)
  869.         loaded = trans.load(qm_file, prop.localization_dir)
  870.  
  871.         if loaded:
  872.             app.installTranslator(trans)
  873.         else:
  874.             loc = 'c'
  875.  
  876.     if loc == 'c':
  877.         log.debug("Using default 'C' locale")
  878.     else:
  879.         log.debug("Using locale: %s" % loc)
  880.         QLocale.setDefault(QLocale(loc))
  881.         prop.locale = loc
  882.         try:
  883.             locale.setlocale(locale.LC_ALL, locale.normalize(loc))
  884.         except locale.Error:
  885.             pass
  886.  
  887.     addrbook = FaxAddrBookForm()
  888.     addrbook.show()
  889.     app.setMainWidget(addrbook)
  890.  
  891.     try:
  892.         log.debug("Starting GUI loop...")
  893.         app.exec_loop()
  894.     except KeyboardInterrupt:
  895.         pass
  896.  
  897.     sys.exit(0)
  898.  
  899. else: # INTERACTIVE_MODE
  900.     try:
  901.         from fax import fax
  902.     except ImportError:
  903.         # This can fail on Python < 2.3 due to the datetime module
  904.         log.error("Fax address book disabled - Python 2.3+ required.")
  905.         sys.exit(1)    
  906.  
  907.     console = Console()
  908.     try:
  909.         console.cmdloop()
  910.     except KeyboardInterrupt:
  911.         log.error("User exit.")
  912.  
  913.     log.info("")
  914.     log.info("Done.")
  915.  
  916.