home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / lib / hplip / base / maint.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-08-31  |  29.1 KB  |  1,161 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. from g import *
  5. from codes import *
  6. import status
  7. import pml
  8. from prnt import pcl, ldl, colorcal
  9.  
  10. def AlignType1(dev, loadpaper_ui):
  11.     ok = loadpaper_ui()
  12.     if ok:
  13.         dev.writeEmbeddedPML(pml.OID_AUTO_ALIGNMENT, pml.AUTO_ALIGNMENT, style = 0)
  14.     
  15.     return ok
  16.  
  17.  
  18. def AlignType2(dev, loadpaper_ui, align_ui, bothpens_ui):
  19.     (state, a, b, c, d) = (0, 6, 6, 3, 3)
  20.     ok = False
  21.     while state != -1:
  22.         if state == 0:
  23.             state = 1
  24.             pens = dev.getStatusFromDeviceID()['agents']
  25.             pen_types = [ pens[x] for x in range(len(pens)) ]
  26.             if AGENT_TYPE_NONE in pen_types:
  27.                 log.error('Cannot perform alignment with 0 or 1 pen installed.')
  28.                 state = 100
  29.             
  30.         AGENT_TYPE_NONE in pen_types
  31.         if state == 1:
  32.             state = -1
  33.             ok = loadpaper_ui()
  34.             if ok:
  35.                 state = 2
  36.             
  37.         ok
  38.         if state == 2:
  39.             state = -1
  40.             alignType2Phase1(dev)
  41.             (ok, a) = align_ui('A', 'h', 'kc', 2, 11)
  42.             if ok:
  43.                 state = 3
  44.             
  45.         ok
  46.         if state == 3:
  47.             state = -1
  48.             (ok, b) = align_ui('B', 'v', 'kc', 2, 11)
  49.             if ok:
  50.                 state = 4
  51.             
  52.         ok
  53.         if state == 4:
  54.             state = -1
  55.             (ok, c) = align_ui('C', 'v', 'kc', 2, 5)
  56.             if ok:
  57.                 state = 5
  58.             
  59.         ok
  60.         if state == 5:
  61.             state = -1
  62.             (ok, d) = align_ui('D', 'v', 'c', 2, 5)
  63.             if ok:
  64.                 state = 6
  65.             
  66.         ok
  67.         if state == 6:
  68.             ok = loadpaper_ui()
  69.             state = -1
  70.             continue
  71.         None if ok else []
  72.         if state == 100:
  73.             ok = False
  74.             bothpens_ui()
  75.             state = -1
  76.             continue
  77.     return ok
  78.  
  79.  
  80. def AlignType3(dev, loadpaper_ui, align_ui, paperedge_ui, align_type):
  81.     (state, a, b, c, d, zca) = (0, 6, 6, 3, 3, 6)
  82.     ok = False
  83.     while state != -1:
  84.         if state == 0:
  85.             state = -1
  86.             ok = loadpaper_ui()
  87.             if ok:
  88.                 alignType3Phase1(dev)
  89.                 state = 1
  90.             
  91.         ok
  92.         if state == 1:
  93.             state = -1
  94.             (ok, a) = align_ui('A', 'h', 'kc', 2, 11)
  95.             if ok:
  96.                 state = 2
  97.             
  98.         ok
  99.         if state == 2:
  100.             state = -1
  101.             (ok, b) = align_ui('B', 'v', 'kc', 2, 11)
  102.             if ok:
  103.                 state = 3
  104.             
  105.         ok
  106.         if state == 3:
  107.             state = -1
  108.             (ok, c) = align_ui('C', 'v', 'k', 2, 11)
  109.             if ok:
  110.                 state = 4
  111.             
  112.         ok
  113.         if state == 4:
  114.             state = -1
  115.             (ok, d) = align_ui('D', 'v', 'kc', 2, 11)
  116.             if ok:
  117.                 state = 5
  118.             
  119.         ok
  120.         if state == 5:
  121.             state = -1
  122.             alignType3Phase2(dev, a, b, c, d)
  123.         None if align_type == 9 else ok
  124.         if state == 6:
  125.             state = -1
  126.             alignType3Phase3(dev)
  127.             (ok, zca) = paperedge_ui(13)
  128.             if ok:
  129.                 state = 7
  130.             
  131.         ok
  132.         if state == 7:
  133.             ok = loadpaper_ui()
  134.             if ok:
  135.                 alignType3Phase4(dev, zca)
  136.             
  137.             state = -1
  138.             continue
  139.     return ok
  140.  
  141.  
  142. def AlignxBow(dev, align_type, loadpaper_ui, align_ui, paperedge_ui, invalidpen_ui, coloradj_ui):
  143.     (state, statepos) = (0, 0)
  144.     user_cancel_states = [
  145.         1000,
  146.         -1]
  147.     (a, b, c, d, e, f, g) = (0, 0, 0, 0, 0, 0, 0)
  148.     error_states = [
  149.         -1]
  150.     ok = False
  151.     dev.pen_config = status.getPenConfiguration(dev.getStatusFromDeviceID())
  152.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  153.         state = 100
  154.         states = [
  155.             -1]
  156.     elif dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  157.         state = 0
  158.         states = [
  159.             2,
  160.             200,
  161.             3,
  162.             -1]
  163.     elif dev.pen_config == AGENT_CONFIG_PHOTO_ONLY:
  164.         state = 0
  165.         states = [
  166.             2,
  167.             200,
  168.             3,
  169.             -1]
  170.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  171.         state = 0
  172.         states = [
  173.             2,
  174.             300,
  175.             3,
  176.             -1]
  177.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  178.         state = 0
  179.         states = [
  180.             2,
  181.             400,
  182.             500,
  183.             600,
  184.             700,
  185.             3,
  186.             4,
  187.             -1]
  188.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  189.         state = 0
  190.         states = [
  191.             2,
  192.             400,
  193.             500,
  194.             600,
  195.             700,
  196.             800,
  197.             900,
  198.             3,
  199.             4,
  200.             -1]
  201.     
  202.     while state != -1:
  203.         if state == 0:
  204.             ok = loadpaper_ui()
  205.             if ok:
  206.                 if align_type == 4:
  207.                     alignType4Phase1(dev)
  208.                 elif align_type == 5:
  209.                     alignType5Phase1(dev)
  210.                 elif align_type == 7:
  211.                     alignType7Phase1(dev)
  212.                 else:
  213.                     statepos = 0
  214.                     states = error_states
  215.             else:
  216.                 statepos = 0
  217.                 states = user_cancel_states
  218.         elif state == 2:
  219.             (ok, a) = paperedge_ui(13)
  220.             if not ok:
  221.                 statepos = 0
  222.                 states = user_cancel_states
  223.             
  224.         elif state == 3:
  225.             if align_type == 4:
  226.                 alignType4Phase2(dev, a, b, c, d, e)
  227.             elif align_type == 5:
  228.                 alignType5Phase2(dev, a, b, c, d, e, f, g)
  229.             else:
  230.                 alignType7Phase2(dev, a, b, c, d, e, f, g)
  231.         elif state == 4:
  232.             ok = loadpaper_ui()
  233.             if ok:
  234.                 if align_type == 4:
  235.                     alignType4Phase3(dev)
  236.                 elif align_type == 5:
  237.                     alignType5Phase3(dev)
  238.                 else:
  239.                     alignType7Phase3(dev)
  240.             else:
  241.                 statepos = 0
  242.                 states = user_cancel_states
  243.         elif state == 100:
  244.             invalidpen_ui()
  245.             state = -1
  246.         elif state == 200:
  247.             (ok, b) = align_ui('B', 'v', 'k', 2, 11)
  248.             if not ok:
  249.                 statepos = 0
  250.                 states = user_cancel_states
  251.             
  252.         elif state == 300:
  253.             (ok, b) = align_ui('B', 'v', 'kc', 2, 11)
  254.             if not ok:
  255.                 statepos = 0
  256.                 states = user_cancel_states
  257.             
  258.         elif state == 400:
  259.             (ok, b) = align_ui('B', 'h', 'kc', 2, 17)
  260.             if not ok:
  261.                 statepos = 0
  262.                 states = user_cancel_states
  263.             
  264.         elif state == 500:
  265.             (ok, c) = align_ui('C', 'v', 'kc', 2, 17)
  266.             if not ok:
  267.                 statepos = 0
  268.                 states = user_cancel_states
  269.             
  270.         elif state == 600:
  271.             (ok, d) = align_ui('D', 'v', 'k', 2, 11)
  272.             if not ok:
  273.                 statepos = 0
  274.                 states = user_cancel_states
  275.             
  276.         elif state == 700:
  277.             (ok, e) = align_ui('E', 'v', 'kc', 2, 11)
  278.             if not ok:
  279.                 statepos = 0
  280.                 states = user_cancel_states
  281.             
  282.         elif state == 800:
  283.             (ok, f) = coloradj_ui('F', 21)
  284.             if not ok:
  285.                 statepos = 0
  286.                 states = user_cancel_states
  287.             
  288.         elif state == 900:
  289.             (ok, f) = coloradj_ui('G', 21)
  290.             if not ok:
  291.                 statepos = 0
  292.                 states = user_cancel_states
  293.             
  294.         elif state == 1000:
  295.             ok = False
  296.             log.warning('Alignment canceled at user request.')
  297.         
  298.         state = states[statepos]
  299.         statepos += 1
  300.     return ok
  301.  
  302.  
  303. def AlignType6(dev, ui1, ui2, loadpaper_ui):
  304.     state = 0
  305.     ok = False
  306.     while state != -1:
  307.         if state == 0:
  308.             state = 2
  309.             accept = ui1()
  310.             if not accept:
  311.                 state = 1
  312.             
  313.         accept
  314.         if state == 1:
  315.             state = -1
  316.             ok = loadpaper_ui()
  317.             if ok:
  318.                 alignType6Phase1(dev)
  319.                 state = 2
  320.             
  321.         ok
  322.         if state == 2:
  323.             ui2()
  324.             state = -1
  325.             continue
  326.     return ok
  327.  
  328.  
  329. def AlignType8(dev, loadpaper_ui, align_ui):
  330.     (state, a, b, c, d) = (0, 5, 5, 5, 5)
  331.     ok = False
  332.     while state != -1:
  333.         if state == 0:
  334.             state = -1
  335.             ok = loadpaper_ui()
  336.             if ok:
  337.                 num_inks = alignType8Phase1(dev)
  338.                 state = 1
  339.             
  340.         ok
  341.         if state == 1:
  342.             state = -1
  343.             (ok, a) = align_ui('A', 'v', 'k', 3, 9)
  344.             if ok:
  345.                 state = 2
  346.             
  347.         ok
  348.         if state == 2:
  349.             state = -1
  350.             (ok, b) = align_ui('B', 'v', 'c', 3, 9)
  351.             if ok:
  352.                 state = 3
  353.             
  354.         ok
  355.         if state == 3:
  356.             state = -1
  357.             (ok, c) = align_ui('C', 'v', 'kc', 3, 9)
  358.             if ok:
  359.                 state = 4
  360.             
  361.         ok
  362.         if state == 4:
  363.             state = -1
  364.             (ok, d) = align_ui('D', 'h', 'kc', 3, 9)
  365.             if ok:
  366.                 state = 5
  367.             
  368.         ok
  369.         if state == 5:
  370.             alignType8Phase2(dev, num_inks, a, b, c, d)
  371.             state = -1
  372.             continue
  373.     return ok
  374.  
  375.  
  376. def AlignType10(dev, loadpaper_ui, align_ui):
  377.     pen_config = status.getPenConfiguration(dev.getStatusFromDeviceID())
  378.     log.debug('Pen config=%d' % pen_config)
  379.     pattern = 1
  380.     if pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  381.         pattern = 2
  382.     elif pen_config in (AGENT_CONFIG_COLOR_AND_PHOTO, AGENT_CONFIG_COLOR_AND_GREY):
  383.         pattern = 3
  384.     
  385.     log.debug('Pattern=%d' % pattern)
  386.     state = 0
  387.     while state != -1:
  388.         if state == 0:
  389.             state = -1
  390.             ok = loadpaper_ui()
  391.             if ok:
  392.                 alignType10Phase1(dev)
  393.                 state = 1
  394.             
  395.         ok
  396.         if state == 1:
  397.             values = align_ui(pattern)
  398.             log.debug(values)
  399.             alignType10Phase2(dev, values, pattern)
  400.             state = 2
  401.             continue
  402.         if state == 2:
  403.             state = -1
  404.             ok = loadpaper_ui()
  405.             if ok:
  406.                 alignType10Phase3(dev)
  407.             
  408.         ok
  409.  
  410.  
  411. def alignType10Phase1(dev):
  412.     dev.writeEmbeddedPML(pml.OID_PRINT_INTERNAL_PAGE, pml.PRINT_INTERNAL_PAGE_ALIGNMENT_PAGE)
  413.  
  414.  
  415. def alignType10Phase2(dev, values, pattern):
  416.     i = 0
  417.     p = ''.join([
  418.         pcl.UEL,
  419.         '\n'])
  420.     for x in values:
  421.         i += 1
  422.         if not x:
  423.             break
  424.         
  425.         p = ''.join([
  426.             p,
  427.             pcl.ESC,
  428.             '*o5W\x1a',
  429.             chr(i),
  430.             '\x00',
  431.             chr(pattern),
  432.             chr(x),
  433.             '\n'])
  434.     
  435.     p = ''.join([
  436.         p,
  437.         pcl.UEL])
  438.     dev.printData(p)
  439.  
  440.  
  441. def alignType10Phase3(dev):
  442.     dev.writeEmbeddedPML(pml.OID_PRINT_INTERNAL_PAGE, pml.PRINT_INTERNAL_PAGE_ALIGNMENT_PAGE_VERIFICATION)
  443.  
  444.  
  445. def alignType2Phase1(dev):
  446.     dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, 0)
  447.     dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, 0)
  448.     dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, 0)
  449.     dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, 0)
  450.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'align1_8xx.pcl.gz'))
  451.  
  452.  
  453. def alignType2Phase2(dev, a, b, c, d):
  454.     dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, (a - 6) * 12)
  455.     dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, (b - 6) * 12)
  456.     dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, (c - 3) * 12)
  457.     dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, (d - 3) * 12)
  458.     dev.writeEmbeddedPML(pml.OID_MARKING_AGENTS_INITIALIZED, 3)
  459.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'align2_8xx.pcl.gz'))
  460.  
  461.  
  462. def alignType3Phase1(dev):
  463.     dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, 0)
  464.     dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, 0)
  465.     dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, 0)
  466.     dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, 0)
  467.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'align1_9xx.pcl.gz'))
  468.  
  469.  
  470. def alignType3Phase2(dev, a, b, c, d):
  471.     dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, (a - 6) * 12)
  472.     dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, (6 - b) * 12)
  473.     dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, (6 - c) * 12)
  474.     dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, (6 - d) * 6)
  475.  
  476.  
  477. def alignType3Phase3(dev):
  478.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'align3_9xx.pcl.gz'))
  479.  
  480.  
  481. def alignType3Phase4(dev, zca):
  482.     dev.writeEmbeddedPML(pml.OID_MARKING_AGENTS_INITIALIZED, 3)
  483.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'align2_9xx.pcl.gz'))
  484.  
  485.  
  486. def alignType4Phase1(dev):
  487.     dev.printData(ldl.buildLIDILPacket(ldl.PACKET_TYPE_RESUME_NORMAL_OPERATION))
  488.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  489.         return None
  490.     elif dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  491.         ldl_file = 'cbbcal.ldl.gz'
  492.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  493.         ldl_file = 'cbccal.ldl.gz'
  494.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  495.         ldl_file = 'cb2pcal.ldl.gz'
  496.     
  497.     dev.printData(ldl.buildSetPrinterAlignmentPacket(0, 0, 0, 0))
  498.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'ldl', ldl_file))
  499.  
  500.  
  501. def alignType4Phase2(dev, a, b, c, d, e):
  502.     log.debug('A=%d, B=%d, C=%d, D=%d, E=%d' % (a, b, c, d, e))
  503.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  504.         return None
  505.     
  506.     zca = (7 - a) * -48
  507.     dev.printData(ldl.buildZCAPacket(zca))
  508.     if dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  509.         k_bidi = (6 - b) * 2
  510.         dev.printData(ldl.buildSetPrinterAlignmentPacket(k_bidi, 0, 0, 0))
  511.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  512.         cmy_bidi = (6 - b) * 2
  513.         dev.printData(ldl.buildSetPrinterAlignmentPacket(0, 0, 0, cmy_bidi))
  514.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  515.         vert = (9 - b) * 2
  516.         hort = (9 - c) * -2
  517.         k_bidi = (6 - d) * 2
  518.         cmy_bidi = (6 - e) * 2
  519.         dev.printData(ldl.buildSetPrinterAlignmentPacket(k_bidi, hort, vert, cmy_bidi))
  520.     
  521.     dev.printData(ldl.buildSetPensAlignedPacket())
  522.  
  523.  
  524. def alignType4Phase3(dev):
  525.     if dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  526.         dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'ldl', 'cb2pcal_done.ldl.gz'))
  527.     
  528.  
  529.  
  530. def alignType5Phase1(dev):
  531.     dev.printData(ldl.buildLIDILPacket(ldl.PACKET_TYPE_RESUME_NORMAL_OPERATION))
  532.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  533.         return None
  534.     elif dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  535.         ldl_file = 'cbbcal.ldl.gz'
  536.     elif dev.pen_config == AGENT_CONFIG_PHOTO_ONLY:
  537.         ldl_file = 'cbpcal.ldl.gz'
  538.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  539.         ldl_file = 'cbccal.ldl.gz'
  540.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  541.         ldl_file = 'cb2pcal.ldl.gz'
  542.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  543.         ldl_file = 'cbcpcal.ldl.gz'
  544.     
  545.     dev.printData(ldl.buildZCAPacket(0))
  546.     dev.printData(ldl.buildColorHortPacket(0))
  547.     dev.printData(ldl.buildColorVertPacket(0))
  548.     dev.printData(ldl.buildBlackVertPacket(0))
  549.     dev.printData(ldl.buildBlackHortPacket(0))
  550.     dev.printData(ldl.buildBlackBidiPacket(0))
  551.     dev.printData(ldl.buildColorBidiPacket(0))
  552.     dev.printData(ldl.buildPhotoHuePacket(0))
  553.     dev.printData(ldl.buildColorHuePacket(0))
  554.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'ldl', ldl_file))
  555.  
  556.  
  557. def alignType5Phase2(dev, a, b, c, d, e, f, g):
  558.     log.debug('A=%d, B=%d, C=%d, D=%d, E=%d, F=%d, G=%d' % (a, b, c, d, e, f, g))
  559.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  560.         return None
  561.     
  562.     zca = (7 - a) * -48
  563.     dev.printData(ldl.buildZCAPacket(zca))
  564.     if dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  565.         k_bidi = (6 - b) * 2
  566.         dev.printData(ldl.buildBlackBidiPacket(k_bidi))
  567.     elif dev.pen_config == AGENT_CONFIG_PHOTO_ONLY:
  568.         kcm_bidi = (6 - b) * 2
  569.         dev.printData(ldl.buildPhotoBidiPacket(kcm_bidi))
  570.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  571.         cmy_bidi = (6 - b) * 2
  572.         dev.printData(ldl.buildColorBidiPacket(cmy_bidi))
  573.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  574.         vert = (9 - b) * 2
  575.         hort = (9 - c) * -2
  576.         k_bidi = (6 - d) * 2
  577.         cmy_bidi = (6 - e) * 2
  578.         dev.printData(ldl.buildColorHortPacket(0))
  579.         dev.printData(ldl.buildColorVertPacket(0))
  580.         dev.printData(ldl.buildBlackVertPacket(vert))
  581.         dev.printData(ldl.buildBlackHortPacket(hort))
  582.         dev.printData(ldl.buildBlackBidiPacket(k_bidi))
  583.         dev.printData(ldl.buildColorBidiPacket(cmy_bidi))
  584.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  585.         vert = (9 - b) * 2
  586.         hort = (9 - c) * -2
  587.         cmy_bidi = (6 - d) * 2
  588.         kcm_bidi = (6 - e) * 2
  589.         photo_adj = colorcal.PHOTO_ALIGN_TABLE[f][g]
  590.         color_adj = colorcal.COLOR_ALIGN_TABLE[f][g]
  591.         dev.printData(ldl.buildPhotoHortPacket(hort))
  592.         dev.printData(ldl.buildPhotoVertPacket(vert))
  593.         dev.printData(ldl.buildColorHortPacket(0))
  594.         dev.printData(ldl.buildColorVertPacket(0))
  595.         dev.printData(ldl.buildPhotoBidiPacket(kcm_bidi))
  596.         dev.printData(ldl.buildColorBidiPacket(cmy_bidi))
  597.         dev.printData(ldl.buildPhotoHuePacket(photo_adj))
  598.         dev.printData(ldl.buildColorHuePacket(color_adj))
  599.     
  600.     dev.printData(ldl.buildSetPensAlignedPacket())
  601.  
  602.  
  603. def alignType5Phase3(dev):
  604.     if dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  605.         dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'ldl', 'cb2pcal_done.ldl.gz'))
  606.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  607.         dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'ldl', 'cbccal_done.ldl.gz'))
  608.     
  609.  
  610.  
  611. def alignType6Phase1(dev):
  612.     dev.printData(ldl.buildPrintInternalPagePacket())
  613.  
  614.  
  615. def alignType7Phase1(dev):
  616.     dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, 0)
  617.     dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, 0)
  618.     dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, 0)
  619.     dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, 0)
  620.     dev.writeEmbeddedPML(pml.OID_AGENT3_VERTICAL_ALIGNMENT, 0)
  621.     dev.writeEmbeddedPML(pml.OID_AGENT3_HORIZONTAL_ALIGNMENT, 0)
  622.     dev.writeEmbeddedPML(pml.OID_AGENT3_BIDIR_ADJUSTMENT, 0)
  623.     dev.writeEmbeddedPML(pml.OID_ZCA, 0)
  624.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  625.         return None
  626.     elif dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  627.         pcl_file = 'crbcal.pcl.gz'
  628.     elif dev.pen_config == AGENT_CONFIG_PHOTO_ONLY:
  629.         pcl_file = 'crpcal.pcl.gz'
  630.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  631.         pcl_file = 'crccal.pcl.gz'
  632.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  633.         pcl_file = 'crcbcal.pcl.gz'
  634.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  635.         pcl_file = 'crcpcal.pcl.gz'
  636.     
  637.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', pcl_file))
  638.  
  639.  
  640. def alignType7Phase2(dev, a, b, c, d, e, f, g):
  641.     log.debug('A=%d, B=%d, C=%d, D=%d, E=%d, F=%d, G=%d' % (a, b, c, d, e, f, g))
  642.     zca = (7 - a) * -12
  643.     dev.writeEmbeddedPML(pml.OID_ZCA, zca)
  644.     if dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  645.         k_bidi = (6 - b) * 6
  646.         dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, k_bidi)
  647.     elif dev.pen_config == AGENT_CONFIG_PHOTO_ONLY:
  648.         kcm_bidi = (6 - b) * 6
  649.         dev.writeEmbeddedPML(pml.OID_AGENT3_BIDIR_ADJUSTMENT, kcm_bidi)
  650.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  651.         cmy_bidi = (6 - b) * 6
  652.         dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, cmy_bidi)
  653.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  654.         vert = (9 - b) * 6
  655.         hort = (9 - c) * -6
  656.         k_bidi = (6 - d) * 6
  657.         cmy_bidi = (6 - e) * 6
  658.         dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, k_bidi)
  659.         dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, cmy_bidi)
  660.         dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, hort)
  661.         dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, vert)
  662.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  663.         vert = (9 - b) * 6
  664.         hort = (9 - c) * -6
  665.         cmy_bidi = (6 - d) * 6
  666.         kcm_bidi = (6 - e) * 6
  667.         photo_adj = colorcal.PHOTO_ALIGN_TABLE[f][g]
  668.         color_adj = colorcal.COLOR_ALIGN_TABLE[f][g]
  669.         x = (color_adj << 8) + photo_adj
  670.         dev.writeEmbeddedPML(pml.OID_COLOR_CALIBRATION_SELECTION, x)
  671.         dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, cmy_bidi)
  672.         dev.writeEmbeddedPML(pml.OID_AGENT3_BIDIR_ADJUSTMENT, kcm_bidi)
  673.         dev.writeEmbeddedPML(pml.OID_AGENT3_HORIZONTAL_ALIGNMENT, hort)
  674.         dev.writeEmbeddedPML(pml.OID_AGENT3_VERTICAL_ALIGNMENT, vert)
  675.     
  676.  
  677.  
  678. def alignType7Phase3(dev):
  679.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'crcaldone.pcl.gz'))
  680.  
  681.  
  682. def alignType8Phase1(dev):
  683.     pens = dev.getStatusFromDeviceID()['agents']
  684.     pen_types = [ pens[x]['type'] for x in range(len(pens)) ]
  685.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', f))
  686.     return num_inks
  687.  
  688.  
  689. def alignType8Phase2(dev, num_inks, a, b, c, d):
  690.     align_values1 = {
  691.         1: '\x00\x00\x18',
  692.         2: '\x00\x00\x12',
  693.         3: '\x00\x00\x0c',
  694.         4: '\x00\x00\x06',
  695.         5: '\x00\x00\x00',
  696.         6: '\x01\x00\x06',
  697.         7: '\x01\x00\x0c',
  698.         8: '\x01\x00\x12',
  699.         9: '\x01\x00\x18' }
  700.     align_values2 = {
  701.         1: '\x00\x00\x12',
  702.         2: '\x00\x00\x0c',
  703.         3: '\x00\x00\x06',
  704.         4: '\x00\x00\x00',
  705.         5: '\x01\x00\x06',
  706.         6: '\x01\x00\x0c',
  707.         7: '\x01\x00\x12',
  708.         8: '\x01\x00\x18',
  709.         9: '\x01\x00\x1e' }
  710.     align_values3 = {
  711.         1: '\x00\x00$',
  712.         2: '\x00\x00\x18',
  713.         3: '\x00\x00\x12',
  714.         4: '\x00\x00\x06',
  715.         5: '\x00\x00\x00',
  716.         6: '\x01\x00\x06',
  717.         7: '\x01\x00\x12',
  718.         8: '\x01\x00\x18',
  719.         9: '\x01\x00$' }
  720.     if num_inks == 4:
  721.         s = ''.join([
  722.             pcl.UEL,
  723.             '@PJL ENTER LANGUAGE=PCL3GUI\n',
  724.             pcl.RESET,
  725.             pcl.ESC,
  726.             '*o5W\x1a\x01',
  727.             align_values1[a],
  728.             pcl.ESC,
  729.             '*o5W\x1a\x02',
  730.             align_values2[a],
  731.             pcl.ESC,
  732.             '*o5W\x1a\x03',
  733.             align_values1[b],
  734.             pcl.ESC,
  735.             '*o5W\x1a\x04',
  736.             align_values1[b],
  737.             pcl.ESC,
  738.             '*o5W\x1a\x08',
  739.             align_values1[c],
  740.             pcl.ESC,
  741.             '*o5W\x1a\x07',
  742.             align_values1[d],
  743.             pcl.RESET,
  744.             pcl.UEL])
  745.     else:
  746.         s = ''.join([
  747.             pcl.UEL,
  748.             '@PJL ENTER LANGUAGE=PCL3GUI\n',
  749.             pcl.RESET,
  750.             pcl.ESC,
  751.             '*o5W\x1a\x05',
  752.             align_values1[a],
  753.             pcl.ESC,
  754.             '*o5W\x1a\x06',
  755.             align_values3[a],
  756.             pcl.ESC,
  757.             '*o5W\x1a\x03',
  758.             align_values1[b],
  759.             pcl.ESC,
  760.             '*o5W\x1a\x04',
  761.             align_values1[b],
  762.             pcl.ESC,
  763.             '*o5W\x1a\n',
  764.             align_values1[c],
  765.             pcl.ESC,
  766.             '*o5W\x1a\t',
  767.             align_values1[d],
  768.             pcl.RESET,
  769.             pcl.UEL])
  770.     dev.printData(s)
  771.  
  772.  
  773. def cleaning(dev, clean_type, level1, level2, level3, loadpaper_ui, dlg1, dlg2, dlg3, wait_ui):
  774.     CLEAN_SLEEP_TIMER = 60
  775.     state = 0
  776.     while state != -1:
  777.         if state == 0:
  778.             state = 1
  779.             if clean_type == 3:
  780.                 ok = loadpaper_ui()
  781.                 if not ok:
  782.                     state = -1
  783.                 
  784.             
  785.         clean_type == 3
  786.         if state == 1:
  787.             level1(dev)
  788.             state = 2
  789.             continue
  790.         if state == 2:
  791.             state = 3
  792.             ok = loadpaper_ui()
  793.             if not ok:
  794.                 state = -1
  795.             
  796.         ok
  797.         if state == 3:
  798.             state = 4
  799.             print_clean_test_page(dev)
  800.             continue
  801.         if state == 4:
  802.             state = -1
  803.             ok = dlg1()
  804.             if not ok:
  805.                 state = 5
  806.             
  807.         ok
  808.         if state == 5:
  809.             level2(dev)
  810.             state = 6
  811.             continue
  812.         if state == 6:
  813.             state = 7
  814.             ok = loadpaper_ui()
  815.             if not ok:
  816.                 state = -1
  817.             
  818.         ok
  819.         if state == 7:
  820.             state = 8
  821.             print_clean_test_page(dev)
  822.             continue
  823.         if state == 8:
  824.             state = -1
  825.             ok = dlg2()
  826.             if not ok:
  827.                 state = 9
  828.             
  829.         ok
  830.         if state == 9:
  831.             level3(dev)
  832.             state = 10
  833.             continue
  834.         if state == 10:
  835.             state = 11
  836.             ok = loadpaper_ui()
  837.             if not ok:
  838.                 state = -1
  839.             
  840.         ok
  841.         if state == 11:
  842.             state = 12
  843.             print_clean_test_page(dev)
  844.             continue
  845.         if state == 12:
  846.             state = -1
  847.             dlg3()
  848.             continue
  849.     return ok
  850.  
  851.  
  852. def print_clean_test_page(dev):
  853.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'ps', 'clean_page.pdf.gz'), raw = False)
  854.  
  855.  
  856. def cleanType1(dev):
  857.     dev.writeEmbeddedPML(pml.OID_CLEAN, pml.CLEAN_CLEAN)
  858.  
  859.  
  860. def primeType1(dev):
  861.     dev.writeEmbeddedPML(pml.OID_CLEAN, pml.CLEAN_PRIME)
  862.  
  863.  
  864. def wipeAndSpitType1(dev):
  865.     dev.writeEmbeddedPML(pml.OID_CLEAN, pml.CLEAN_WIPE_AND_SPIT)
  866.  
  867.  
  868. def cleanType2(dev):
  869.     p = ldl.buildLIDILPacket(ldl.PACKET_TYPE_COMMAND, ldl.COMMAND_HANDLE_PEN, ldl.COMMAND_HANDLE_PEN_CLEAN_LEVEL1)
  870.     dev.printData(p)
  871.  
  872.  
  873. def primeType2(dev):
  874.     p = ldl.buildLIDILPacket(ldl.PACKET_TYPE_COMMAND, ldl.COMMAND_HANDLE_PEN, ldl.COMMAND_HANDLE_PEN_CLEAN_LEVEL2)
  875.     dev.printData(p)
  876.  
  877.  
  878. def wipeAndSpitType2(dev):
  879.     p = ldl.buildLIDILPacket(ldl.PACKET_TYPE_COMMAND, ldl.COMMAND_HANDLE_PEN, ldl.COMMAND_HANDLE_PEN_CLEAN_LEVEL3)
  880.     dev.printData(p)
  881.  
  882.  
  883. def colorCalType1(dev, loadpaper_ui, colorcal_ui, photopenreq_ui):
  884.     (value, state) = (4, 0)
  885.     ok = False
  886.     while state != -1:
  887.         if state == 0:
  888.             if colorCalType1PenCheck(dev):
  889.                 state = 1
  890.             else:
  891.                 state = 100
  892.         colorCalType1PenCheck(dev)
  893.         if state == 1:
  894.             state = -1
  895.             ok = loadpaper_ui()
  896.             if ok:
  897.                 colorCalType1Phase1(dev)
  898.                 state = 2
  899.             
  900.         ok
  901.         if state == 2:
  902.             state = -1
  903.             (ok, value) = colorcal_ui()
  904.             if ok:
  905.                 state = 3
  906.             
  907.         ok
  908.         if state == 3:
  909.             colorCalType1Phase2(dev, value)
  910.             state = -1
  911.             continue
  912.         if state == 100:
  913.             ok = False
  914.             photopenreq_ui()
  915.             state = -1
  916.             continue
  917.     return ok
  918.  
  919.  
  920. def colorCalType1PenCheck(dev):
  921.     pens = dev.getStatusFromDeviceID()['agents']
  922.     pen_types = [ pens[x]['type'] for x in range(len(pens)) ]
  923.  
  924.  
  925. def colorCalType1Phase1(dev):
  926.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'colorcal1_450.pcl.gz'))
  927.  
  928.  
  929. def colorCalType1Phase2(dev, value):
  930.     color_cal = {
  931.         1: ('\x0f<', '\x17\x0c'),
  932.         2: ('\x10\xcc', '\x15|'),
  933.         3: ('\x12\\', '\x13\xec'),
  934.         4: ('\x13\xec', '\x12\\'),
  935.         5: ('\x15|', '\x10\xcc'),
  936.         6: ('\x17\x0c', '\x0f<'),
  937.         7: ('\x18\x9c', '\r\xac') }
  938.     s = ''.join([
  939.         pcl.UEL,
  940.         '@PJL ENTER LANGUAGE=PCL3GUI\n',
  941.         pcl.RESET,
  942.         pcl.ESC,
  943.         '*o5W\x1a\x0c\x00',
  944.         color_cal[value][0],
  945.         pcl.ESC,
  946.         '*o5W\x1a\x0b\x00',
  947.         color_cal[value][1],
  948.         pcl.RESET,
  949.         pcl.UEL])
  950.     dev.printData(s)
  951.  
  952.  
  953. def colorCalType2(dev, loadpaper_ui, colorcal_ui, photopenreq_ui):
  954.     (value, state) = (4, 0)
  955.     ok = True
  956.     while state != -1:
  957.         if state == 0:
  958.             if colorCalType2PenCheck(dev):
  959.                 state = 1
  960.             else:
  961.                 state = 100
  962.         colorCalType2PenCheck(dev)
  963.         if state == 1:
  964.             state = -1
  965.             ok = loadpaper_ui()
  966.             if ok:
  967.                 colorCalType2Phase1(dev)
  968.                 state = 2
  969.             
  970.         ok
  971.         if state == 2:
  972.             state = -1
  973.             (ok, value) = colorcal_ui()
  974.             if ok:
  975.                 state = 3
  976.             
  977.         ok
  978.         if state == 3:
  979.             colorCalType2Phase2(dev, value)
  980.             state = -1
  981.             continue
  982.         if state == 100:
  983.             photopenreq_ui()
  984.             ok = False
  985.             state = -1
  986.             continue
  987.     return ok
  988.  
  989.  
  990. def colorCalType2PenCheck(dev):
  991.     pens = dev.getStatusFromDeviceID()['agents']
  992.     pen_types = [ pens[x]['type'] for x in range(len(pens)) ]
  993.  
  994.  
  995. def colorCalType2Phase1(dev):
  996.     dev.writeEmbeddedPML(pml.OID_PRINT_INTERNAL_PAGE, pml.PRINT_INTERNAL_PAGE_COLOR_CAL)
  997.  
  998.  
  999. def colorCalType2Phase2(dev, value):
  1000.     c = colorcal.COLOR_CAL_TABLE
  1001.     p = ''.join([
  1002.         '\x1b&b19WPML \x04\x00\x06\x01\x04\x01\x05\x01\t\x08\x04',
  1003.         chr(c[value * 4] + 100),
  1004.         chr(c[value * 4 + 1] + 100),
  1005.         chr(c[value * 4 + 2] + 100),
  1006.         chr(c[value * 4 + 3] + 100),
  1007.         '\x1b%-12345X'])
  1008.     dev.printData(p)
  1009.  
  1010.  
  1011. def colorCalType3(dev, loadpaper_ui, colorcal_ui, photopenreq_ui):
  1012.     (value, state) = (4, 0)
  1013.     ok = True
  1014.     while state != -1:
  1015.         if state == 0:
  1016.             if colorCalType3PenCheck(dev):
  1017.                 state = 1
  1018.             else:
  1019.                 state = 100
  1020.         colorCalType3PenCheck(dev)
  1021.         if state == 1:
  1022.             state = -1
  1023.             ok = loadpaper_ui()
  1024.             if ok:
  1025.                 colorCalType3Phase1(dev)
  1026.                 state = 2
  1027.             
  1028.         ok
  1029.         if state == 2:
  1030.             state = -1
  1031.             (ok, valueA) = colorcal_ui('A', 21)
  1032.             if ok:
  1033.                 state = 3
  1034.             
  1035.         ok
  1036.         if state == 3:
  1037.             state = -1
  1038.             (ok, valueB) = colorcal_ui('B', 21)
  1039.             if ok:
  1040.                 state = 4
  1041.             
  1042.         ok
  1043.         if state == 4:
  1044.             colorCalType3Phase2(dev, valueA, valueB)
  1045.             state = -1
  1046.             continue
  1047.         if state == 100:
  1048.             photopenreq_ui()
  1049.             ok = False
  1050.             state = -1
  1051.             continue
  1052.     return ok
  1053.  
  1054.  
  1055. def colorCalType3PenCheck(dev):
  1056.     pens = dev.getStatusFromDeviceID()['agents']
  1057.     pen_types = [ pens[x]['type'] for x in range(len(pens)) ]
  1058.  
  1059.  
  1060. def colorCalType3Phase1(dev):
  1061.     dev.writeEmbeddedPML(pml.OID_PRINT_INTERNAL_PAGE, pml.PRINT_INTERNAL_PAGE_COLOR_CAL)
  1062.  
  1063.  
  1064. def colorCalType3Phase2(dev, A, B):
  1065.     photo_adj = colorcal.PHOTO_ALIGN_TABLE[A][B]
  1066.     color_adj = colorcal.COLOR_ALIGN_TABLE[A][B]
  1067.     adj_value = (color_adj << 0x8L) + photo_adj
  1068.     dev.writeEmbeddedPML(pml.OID_COLOR_CALIBRATION_SELECTION, adj_value)
  1069.  
  1070.  
  1071. def colorCalType4(dev, loadpaper_ui, colorcal_ui, wait_ui):
  1072.     state = 0
  1073.     ok = True
  1074.     while state != -1:
  1075.         if state == 0:
  1076.             state = -1
  1077.             ok = loadpaper_ui()
  1078.             if ok:
  1079.                 colorCalType4Phase1(dev)
  1080.                 state = 2
  1081.             
  1082.         ok
  1083.         if state == 2:
  1084.             state = -1
  1085.             (ok, values) = colorcal_ui()
  1086.             if ok:
  1087.                 state = 3
  1088.             
  1089.         ok
  1090.         if state == 3:
  1091.             colorCalType4Phase2(dev, values)
  1092.             state = 4
  1093.             continue
  1094.         if state == 4:
  1095.             state = -1
  1096.             ok = loadpaper_ui()
  1097.             if ok:
  1098.                 colorCalType4Phase3(dev)
  1099.                 state = -1
  1100.             
  1101.         ok
  1102.     return ok
  1103.  
  1104.  
  1105. def colorCalType4Phase1(dev):
  1106.     dev.writeEmbeddedPML(pml.OID_PRINT_INTERNAL_PAGE, pml.PRINT_INTERNAL_PAGE_COLOR_CAL)
  1107.  
  1108.  
  1109. def colorCalType4AdjValue(value):
  1110.     if value >= 100:
  1111.         return 200
  1112.     
  1113.     return value + 100
  1114.  
  1115.  
  1116. def colorCalType4Phase2(dev, values):
  1117.     if -1 in values:
  1118.         (Cadj, Madj, Yadj, cadj, madj, kadj) = (244, 244, 244, 244, 244, 244)
  1119.     else:
  1120.         (sel1, sel2, sel3, sel4) = values
  1121.         tmp1 = colorcal.TYPE_4_C_TABLE[sel1][sel2]
  1122.         tmp2 = colorcal.TYPE_4_LC_TABLE[sel3][sel4]
  1123.         Cadj = colorCalType4AdjValue(tmp1)
  1124.         cadj = colorCalType4AdjValue(tmp1 + tmp2)
  1125.         tmp1 = colorcal.TYPE_4_M_TABLE[sel1][sel2]
  1126.         tmp2 = colorcal.TYPE_4_LM_TABLE[sel3][sel4]
  1127.         Madj = colorCalType4AdjValue(tmp1)
  1128.         madj = colorCalType4AdjValue(tmp1 + tmp2)
  1129.         Yadj = colorCalType4AdjValue(colorcal.TYPE_4_Y_TABLE[sel1][sel2])
  1130.         kadj = colorCalType4AdjValue(0)
  1131.     log.debug('C=%d, M=%d, Y=%d, c=%d, m=%d, k=%d\n' % (Cadj, Madj, Yadj, cadj, madj, kadj))
  1132.     dev.writeEmbeddedPML(pml.OID_COLOR_CALIBRATION_ARRAY_1, kadj)
  1133.     dev.writeEmbeddedPML(pml.OID_COLOR_CALIBRATION_ARRAY_2, Cadj)
  1134.     dev.writeEmbeddedPML(pml.OID_COLOR_CALIBRATION_ARRAY_3, Madj)
  1135.     dev.writeEmbeddedPML(pml.OID_COLOR_CALIBRATION_ARRAY_4, Yadj)
  1136.     dev.writeEmbeddedPML(pml.OID_COLOR_CALIBRATION_ARRAY_5, cadj)
  1137.     dev.writeEmbeddedPML(pml.OID_COLOR_CALIBRATION_ARRAY_6, madj)
  1138.  
  1139.  
  1140. def colorCalType4Phase3(dev):
  1141.     dev.writeEmbeddedPML(pml.OID_PRINT_INTERNAL_PAGE, pml.PRINT_INTERNAL_PAGE_COLOR_PALETTE_CMYK_PAGE)
  1142.  
  1143.  
  1144. def colorCalType5(dev, loadpaper_ui):
  1145.     if loadpaper_ui():
  1146.         dev.printData('\x1b%-12345X@PJL ENTER LANGUAGE=PCL3GUI\n\x1bE\x1b%Puifp.multi_button_push 20;\nudw.quit;\x1b*rC\x1bE\x1b%-12345X')
  1147.     
  1148.  
  1149.  
  1150. def linefeedCalType1(dev, loadpaper_ui):
  1151.     if loadpaper_ui():
  1152.         dev.printData('\x1b%-12345X@PJL ENTER LANGUAGE=PCL3GUI\n\x1bE\x1b%Puifp.multi_button_push 3;\nudw.quit;\x1b*rC\x1bE\x1b%-12345X')
  1153.     
  1154.  
  1155.  
  1156. def printQualityDiagType1(dev, loadpaper_ui):
  1157.     if loadpaper_ui():
  1158.         dev.printData('\x1b%-12345X@PJL ENTER LANGUAGE=PCL3GUI\n\x1bE\x1b%Puifp.multi_button_push 14;\nudw.quit;\x1b*rC\x1bE\x1b%-12345X')
  1159.     
  1160.  
  1161.