`9Sc@sdZdddfddfgZddlZddlZddlZddlZddlmZddlZd Z d Z d Z d Z d Z dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!dZ"dZ#dZ$dZ%dZ&dZ'dZ(dZ)e)Z*dZ+dZ,dZ-dZ.dZ/dZ0dZ1dZ2dZ3dZ4dZ5dZ6dZ7dZ8dZ9dZ:dZ;dZ<dZ=dZ>dZ?dZ@d ZAd!ZBdZCd"ZDd#ZEdZFdZGdZHdZIdZJdZKdZLdZMdZNdZOd$ZPd%ZQd&ZRd'ZSd(ZTdZUd)ZVd*ZWd*ZXdZYdZZdZ[dZ\dZ]dZ^dZ_d+Z`dZae`e]eZeaZbdZcd,Zdd-Zed-Zfd.Zgd/Zhd/Zid0Zjd1Zkd1Zld2Zmd3Znd3Zod4Zpd4ZqdZrdZsdZtd5Zud6ZvevZwd7Zxd8Zyd9Zzd:Z{d;Z|d<Z}d=Z~d>Zd?ZeZd@ZdAZdBZdCZdDZdEZdFZdGZdHZdIZdJZdKZdLZdMZdNZdOZdPZdQZdRZdSZdTZdUZdVZdWZdXZdYZdZZdZdZdZdZdZdZdZdZdZdZdZdZdZd)Zd[Zd5ZdZdZdZdZdZdZdZdZdZdZd)Zd[Zd\Zd]Zd^ZdZdZdZdZdZdZdZdZdZdZdZeZeZdZdZdZdZdZdZdZdZd_Zd`ZdaZdbfdcYZddfdeYZdfefdgYZdhfdiYZiZxWeeD]IZeeeeZeoeeoeeereeej} is the published interface for enhanced metafiles, which is also a file-based representation of the Windows graphics device interface. This API follows most of the naming conventions of ECMA-234, and most of the parameter lists of methods are the same as their ECMA-234 equivalents. The primary difference is that pyemf has extended the API to be object-oriented based on the class L{EMF}. So, while in ECMA-234 the first argument is generally the device context, here in pyemf it is implicit in the class instance. ECMA-234 defines a lot of constants (mostly integers that are used as flags to various functions) that pyemf defines as module level variables. So, rather than pollute your global namespace, it is recommended that you use C{import pyemf} rather than C{from pyemf import *}. Introduction ============ To use pyemf in your programs, you L{instantiate} an L{EMF} object, draw some stuff using its methods, and save the file. An example:: #!/usr/bin/env python import pyemf width=8.0 height=6.0 dpi=300 emf=pyemf.EMF(width,height,dpi) thin=emf.CreatePen(pyemf.PS_SOLID,1,(0x01,0x02,0x03)) emf.SelectObject(thin) emf.Polyline([(0,0),(width*dpi,height*dpi)]) emf.Polyline([(0,height*dpi),(width*dpi,0)]) emf.save("test-1.emf") This small program creates a 8in x 6in EMF at 300 dots per inch, and draws two lines connecting the opposite corners. This simple test is available as C{test-1.py} in the C{examples} directory of the pyemf distribution. There are many other small test programs to demonstrate other features of the EMF class. Naming Conventions in pyemf =========================== Methods that belong to ECMA-234 are C{CamelCased} starting with a capital letter. Methods that apply to the operation of the L{EMF} class itself (i.e. L{load} and L{save}) are C{lower} cased. Constants described in L{pyemf} that are used as parameters are C{ALL_UPPER_CASE}. Coordinate System ================= Coordinates are addressed a coordinate system called B{page space} by integer pixels in a horizontal range (increasing to the right) from C{0} to C{width*density}, and vertically (from the top down) C{0} to C{height*density}. Density is either dots per inch if working in english units, or dots per millimeter if working in metric. World and Page Space -------------------- Note that there are four coordinate spaces used by GDI: world, page, device, and physical device. World and page are the same, unless a world transform (L{SetWorldTransform}, L{ModifyWorldTransform}) is used. In that case, you operate in world space (that is transformed into page space by multiplying by the transformation matrix), and it could be scaled differently. Experimental Coordinate System ------------------------------ Experimental support for device coordinates is available through L{SetMapMode} and the various Window and Viewport methods. Device coordinates are referenced by physical dimensions corresponding to the mapping mode currently used. [The methods work correctly (in the sense that they generate the correct records in the metafile) and the API won't change, but it's not clear to me what the parameters should do.] Drawing Characteristics ======================= GDI has a concept of the B{current object} for the each of the three drawing characteristics: line style, fill style, and font. Once a characteristic is made current using L{SelectObject}, it remains current until it is replaced by another call to SelectObject. Note that a call to SelectObject only affects that characteristic, and not the other two, so changing the line style doesn't effect the fill style or the font. Additionally, there is a set of B{stock objects} retrievable with L{GetStockObject} that should be available on any system capable of rendering an EMF. Colors ------ A quick note about color. Colors in pyemf are specified one of three ways: - (r,g,b) tuple, where each component is a integer between 0 and 255 inclusive. - (r,g,b) tuple, where each component is a float between 0.0 and 1.0 inclusive. - packed integer created by a call to L{RGB} Line Styles ----------- Line styles are created by L{CreatePen} and specify the style, width, and color. Note that there is a NULL_PEN stock object if you don't actually want to draw a line with a drawing primitive. Fill Styles ----------- Polygon fill styles are created by L{CreateSolidBrush} and theoretically L{CreateHatchBrush}, although the latter doesn't seem to be supported currently in OpenOffice. So, reliably we can only use CreateSolidBrush and thus can only specify a fill color and not a fill pattern. Note that there is a stock object NULL_BRUSH that doesn't fill, useful if you want to only draw an outline of a primitive that is normally filled. An interesting side-note is that there is no direct support for gradients in EMF. Examining some .emfs that do have gradients shows that Windows produces them using clipping regions and subdividing the object into areas of a single color an drawing slices of the individual color. Better support for clipping regions is the subject of a future release of pyemf, but they also don't seem to work well in OpenOffice, so it hasn't been a high priority. Fonts ----- L{CreateFont} requires a large number of parameters, the most important being the height, the rotation, and the name. Note that the height can either be specified as a positive or negative integer, where negative means use that value as the average I{glyph} height and positive means use the value as the average I{cell} height. Since a glyph is contained within a cell, the negative value will yield a slightly larger font when rendered on screen. Note that the two rotation values must specify the same angle. Also note that font color is not part of a L{SelectObject} characteristic. It is specified using the separate method L{SetTextColor}. L{SetBkMode} and L{SetBkColor} are supposed to work with text, but in my testing with OpenOffice it hasn't been consistent. I tend to just C{SetBkMode(pyemf.TRANSPARENT)} and leave it at that. Drawing ======= The methods listed under B{Drawing Primitives} below use either the current line style or the current fill style (or both). Any primitive that creates a closed figure (L{Polygon}, L{PolyPolygon}, L{Rectangle}, L{RoundRect}, L{Ellipse}, L{Chord}, and L{Pie}) will use both the line and fill style. Others (L{Polyline}, L{PolyPolyline} and L{Arc}) will only use the line style, excepting L{SetPixel} which doesn't use either. Paths ===== To create more complicated shapes, the B{Path Primitives} are used. A path is started with a call to L{BeginPath} and the initial point should be set with L{MoveTo}. Calls to L{LineTo}, L{PolylineTo}, L{ArcTo}, and L{PolyBezierTo} extend the path. L{CloseFigure} should be used to connect the final point to the starting point, otherwise the path may be filled incorrectly. L{EndPath} then completes the path, and it may be outlined with L{StrokePath}, filled with L{FillPath} or both with L{StrokeAndFillPath}. Note that OpenOffice ignores L{ArcTo} in terms of path continuity -- the arc is drawn, but it is not connected to the path. Note that L{SelectClipPath} is broken in OpenOffice. Coordinate System Transformation ================================ You might have noticed that methods like L{Ellipse} and L{Rectangle} can only create objects that are aligned with the X-Y axis. This would be a real limitation without some way to rotate the figures. L{SetWorldTransform} and L{ModifyWorldTransform} provide this. These methods provide a generalized linear transformation that can translate, rotate, scale and shear subsequent graphics operations. These methods aren't required by the ECMA-234 spec, which may explain why their support in OpenOffice is mixed. Drawing primitives and paths seem to be supported and are transformed, but text is not (though it should be). @author: $author @version: $version tgdis GDI Commands GDI CommandstoosOpenOffice SupportiN(tStringIOs2.0.0s Rob McMullensrobm@users.sourceforge.netshttp://pyemf.sourceforge.nets<http://sourceforge.net/project/showfiles.php?group_id=148144s%Pure Python Enhanced Metafile Librarys/graphics, scalable, vector, image, clipart, emftLGPLiiiiiiiiii iiiiii iiii i i i iiiiidii,iiiXii iiiiiiiiiiiiiiiMiiiiiiiillllll l@lllllll l@li i0i@iPcCs|dddS(sRound to the nearest multiple of 4 greater than or equal to the given number. EMF records are required to be aligned to 4 byte boundaries.ii((tnum((s&code\common\utils\third_party\pyemf.pyt_round4scCst|tr"td|}n|dkr7d}n|dkrLd}nt|trntd|}n|dkrd}n|dkrd}nt|trtd|}n|dkrd}n|dkrd}n|d>|d>B|BS(sh Pack integer color values into a 32-bit integer format. @param r: 0 - 255 or 0.0 - 1.0 specifying red @param g: 0 - 255 or 0.0 - 1.0 specifying green @param b: 0 - 255 or 0.0 - 1.0 specifying blue @return: single integer that should be used when any function needs a color value @rtype: int @type r: int or float @type g: int or float @type b: int or float iiii(t isinstancetfloattint(trtgtb((s&code\common\utils\third_party\pyemf.pytRGBs&      cCsKt|tr|St|ts1t|tr;t|StddS(s Normalize the input into a packed integer. If the input is a tuple, pass it through L{RGB} to generate the color value. @param c: color @type c: int or (r,g,b) tuple @return: packed integer color from L{RGB} @rtype: int s<Color must be specified as packed integer or 3-tuple (r,g,b)N(RRttupletlistR t TypeError(tc((s&code\common\utils\third_party\pyemf.pyt_normalizeColors  t_DCcBs\eZdZdddddZdZdZdZd d Zd Zd Z RS( sDevice Context state machine. This is used to simulate the state of the GDI buffer so that some user commands can return information. In a real GDI implementation, there'd be lots of error checking done, but here we can't do a whole bunch because we're outputting to a metafile. So, in general, we assume success. Here's Microsoft's explanation of units: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/gdi/cordspac_3qsz.asp Window <=> Logical units <=> page space or user addressable integer pixel units. Viewport <=> Physical units <=> device units and are measured in actual dimensions, like .01 mm units. There are four coordinate spaces used by GDI: world, page, device, and physical device. World and page are the same, unless a world transform is used. These are addressed by integer pixels. Device coordinates are referenced by physical dimensions corresponding to the mapping mode currently used. s6.0s4.0t72tincCsd|_d|_g|_|jjdg|_d|_d|_d|_d|_ d|_ d|_ |dkr|j ddt |dt |dn*|j ddt |dt |dd|_d|_|jddt ||t ||tddd|_d|_d|_|j d||_|j d||_d|_d|_|j|_|j|_dS( Niiii@itmmidi (txtytobjectstappendtNonet objectholestref_pixelwidthtref_pixelheightt ref_widtht ref_heighttwidththeighttsetPhysicalSizeRt pixelwidtht pixelheightt setPixelSizeR t text_colort viewport_xt viewport_ytviewport_ext_xtviewport_ext_ytwindow_xtwindow_yt window_ext_xt window_ext_y(tselfR R!tdensitytunits((s&code\common\utils\third_party\pyemf.pyt__init__Js4           -*  *     cCs|j|j|j|j|j|jdkrT|jd|_|jd|_n |j d|_|j d|_|j |j |j |j|j|j|_|j|_dS(s3Extract the dimensions from an _EMR._HEADER record.ii idN(R"t rclFrame_leftt rclFrame_toptrclFrame_righttrclFrame_bottomtszlMicrometers_cxRtszlMicrometers_cyRtszlMillimeters_cxtszlMillimeters_cyR%trclBounds_leftt rclBounds_toptrclBounds_righttrclBounds_bottomt szlDevice_cxRt szlDevice_cyR(R/theader((s&code\common\utils\third_party\pyemf.pyt getBoundss cCsB|||_|||_||_||_||_||_dS(sUSet the physical (i.e. stuff you could measure with a meterstick) dimensions.N(R R!t frame_leftt frame_topt frame_rightt frame_bottom(R/tleftttoptrighttbottom((s&code\common\utils\third_party\pyemf.pyR"s      cCsB|||_|||_||_||_||_||_dS(s%Set the pixel-addressable dimensions.N(R#R$t bounds_leftt bounds_topt bounds_rightt bounds_bottom(R/RGRHRIRJ((s&code\common\utils\third_party\pyemf.pyR%s      icCst|j}|dkrX||krH|jdg||d7_n||j||jr|jj}||j|(R/tbounds((s&code\common\utils\third_party\pyemf.pyt setBoundsPs   cCsdS(s3Return bounds of object, or None if not applicable.N(R(R/((s&code\common\utils\third_party\pyemf.pyRBYsicCsB|dkr!||_||_ntjdd\|_|_|jdkr>|jd|_|j|j|_|jjdkr |jjt |jkr|jjt |j|_ |jd|j 7_nt tj|jj |jd|jj!|_ n|j|jjkr>|j|j|jjq>ndS(sRead data from the file object and, using the format structure defined by the subclass, parse the data and store it in self.values[] list.is>> (RRRaRRtUnicodeEncodeErrorRtgetvalue(R/RRrRsRtR((s&code\common\utils\third_party\pyemf.pyt str_detailss     cCsbd}|j}|r$tj}nd|jjjd|j|j|jj |jj ||fS(NRs1**%s: iType=%s nSize=%s struct='%s' size=%d %s%st_( RtostlinesepRwR\tlstripRxRyRReRf(R/trettdetails((s&code\common\utils\third_party\pyemf.pyt__str__s   >(Nt( R\R]R^RkRRRttwobytepaddingR2RRRRRBRRRRRRRRRRRRRRRRRR(((s&code\common\utils\third_party\pyemf.pyRus:                 t_EMRcBs8eZdefdYZdefdYZdefdYZdefdYZdefd YZd efd YZd efd YZ de fdYZ defdYZ defdYZ de fdYZ de fdYZde fdYZdefdYZdefdYZdefdYZd efd!YZd"efd#YZd$efd%YZd&efd'YZd(efd)YZd*efd+YZd,efd-YZd.efd/YZd0efd1YZd2efd3YZd4efd5YZd6efd7YZd8efd9YZd:efd;YZ d<efd=YZ!d>efd?YZ"d@efdAYZ#dBefdCYZ$dDe"fdEYZ%dFefdGYZ&dHefdIYZ'dJe'fdKYZ(dLefdMYZ)dNefdOYZ*dPe*fdQYZ+dRe*fdSYZ,dTefdUYZ-dVefdWYZ.dXefdYYZ/dZe*fd[YZ0d\efd]YZ1d^efd_YZ2d`efdaYZ3dbefdcYZ4ddefdeYZ5dfe5fdgYZ6dhe5fdiYZ7djefdkYZ8dlefdmYZ9dnefdoYZ:dpefdqYZ;drefdsYZ<dtefduYZ=dvefdwYZ>dxe>fdyYZ?dzefd{YZ@d|e@fd}YZAd~e@fdYZBdefdYZCdeCfdYZDde fdYZEdeEfdYZFde.fdYZGde.fdYZHde.fdYZIdefdYZJRS(t_HEADERcBseZdZdZd,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEgZd%d&Zd'Zd(Zd)Zd*Z d+Z RS(FsHeader has different fields depending on the version of windows. Also note that if offDescription==0, there is no description string.iRYR;R<R=R>R3R4R5R6t dSignaturei EMFtnVersionitnBytesitnRecordsthtnHandlest sReservedt nDescriptiontoffDescriptiont nPalEntriesR?iR@iR9i@R:it cbPixelFormattoffPixelFormattbOpenGLR7R8RcCs~tj|t|tr1|jd|_nt|dkrhdtjdd|d|_nt|j|_dS(Nsutf-8iupyemf uu( RuR2RRlRt descriptionROt __version__R(R/R((s&code\common\utils\third_party\pyemf.pyR2s  %cCs|jrdt|GHn|jdkr|j|j}|||d|j!}|jd|_|jrd|jGHqndS(Nsfound %d extra bytes.iisutf-16lesstr: %s(RzRORRRRR(R/R|RR((s&code\common\utils\third_party\pyemf.pyR/s  cCsVt}|jdt|j|jdtjd|jjd|jS(Ns unicode string: %s s%s t16ssutf-16le(RRRlRRoRRR(R/R((s&code\common\utils\third_party\pyemf.pyR<s )cCs|j|_|j|_|j|_|j|_|j|_ |j |_ |j |_ |j|_|r|j|_|j|_|jd|_|jd|_n8|j|_|j|_|jd|_|jd|_|jd|_|jd|_dS(Ni i(RKR;RLR<RMR=RNR>RCR3RDR4RER5RFR6R#R?R$R@R R7R!R8RRRRR9R:(R/tdct scaleheader((s&code\common\utils\third_party\pyemf.pyRBs&            cCs|jdkr2|jd|_|jd|_nt|j|_|jdkre|j|_n d|_t |jd}|S(Niii( R7R9R:R8RORRRRR(R/t sizestring((s&code\common\utils\third_party\pyemf.pyR]s cCs|j||jdS(N(RR(R/R((s&code\common\utils\third_party\pyemf.pyRks(RYsrclBounds_left(RYs rclBounds_top(RYsrclBounds_right(RYsrclBounds_bottom(RYs rclFrame_left(RYs rclFrame_top(RYsrclFrame_right(RYsrclFrame_bottom(RYRi EMF(RYRi(RYsnBytesi(RYsnRecordsi(RsnHandlesi(RRi(RYs nDescriptioni(RYsoffDescriptioni(RYRi(RYs szlDevice_cxi(RYs szlDevice_cyi(RYsszlMillimeters_cxi@(RYsszlMillimeters_cyi(RYRi(RYRi(RYRi(RYsszlMicrometers_cx(RYsszlMicrometers_cy( R\R]R^RkRR2RRRRR(((s&code\common\utils\third_party\pyemf.pyRsD     t _POLYBEZIERcBs\eZdZd ddddgZdZgddZd Zd Zd Zd Z RS(iRYR;R<R=R>tcptlicCs6tj||j|t||_||_dS(N(RuR2RRORtaptl(R/tpointsR((s&code\common\utils\third_party\pyemf.pyR2ys  cCs1d}|j|j|j||\}|_dS(Ni(Rtemr_point_typeRR(R/R|R((s&code\common\utils\third_party\pyemf.pyRs cCstj|jd|jS(Ni(RoRpRR(R/((s&code\common\utils\third_party\pyemf.pyRscCs|j||j|jdS(N(RRR(R/R((s&code\common\utils\third_party\pyemf.pyRscCs3t}d}|jdt|j|jS(Nis points: %s (RRRlRR(R/RR((s&code\common\utils\third_party\pyemf.pyRs (RYsrclBounds_left(RYs rclBounds_top(RYsrclBounds_right(RYsrclBounds_bottom(RYscptl(iiii( R\R]RkRRR2RRRR(((s&code\common\utils\third_party\pyemf.pyRps    t_POLYGONcBseZdZRS(i(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRst _POLYLINEcBseZdZRS(i(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRst _POLYBEZIERTOcBseZdZdZRS(icCs|j|j|j|jfS(N(R;R<R=R>(R/((s&code\common\utils\third_party\pyemf.pyRBs (R\R]RkRB(((s&code\common\utils\third_party\pyemf.pyRst _POLYLINETOcBseZdZRS(i(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRst _POLYPOLYLINEcBsbeZdZddddddgZdZggdd Zd Zd Zd Zd Z RS(iRYR;R<R=R>tnPolysRicCsNtj||j|t||_||_t||_||_dS(N(RuR2RRORRRt aPolyCounts(R/Rt polycountsR((s&code\common\utils\third_party\pyemf.pyR2s    cCsUd}|jd|j||\}|_|j|j|j||\}|_dS(NiRY(RRRRRRR(R/R|R((s&code\common\utils\third_party\pyemf.pyRs$cCs/tjd|jtj|jd|jS(NRYi(RoRpRRR(R/((s&code\common\utils\third_party\pyemf.pyRscCs3|j|d|j|j||j|jdS(NRY(RRRRR(R/R((s&code\common\utils\third_party\pyemf.pyRsc Cst}d}xrt|jD]a}|jd||j|f|jdt|j|||j|!||j|7}qW|jS(Nis Polygon %d: %d points s %s (RRRRRRlRR(R/RRtn((s&code\common\utils\third_party\pyemf.pyRs ,(RYsrclBounds_left(RYs rclBounds_top(RYsrclBounds_right(RYsrclBounds_bottom(RYsnPolys(RYscptl(iiii( R\R]RkRRR2RRRR(((s&code\common\utils\third_party\pyemf.pyRs   t _POLYPOLYGONcBseZdZRS(i(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRst_SETWINDOWEXTEXcBs)eZdZddgZdddZRS(i RYt szlExtent_cxt szlExtent_cyicCs#tj|||_||_dS(N(RuR2RR(R/tcxtcy((s&code\common\utils\third_party\pyemf.pyR2s  (RYs szlExtent_cx(RYs szlExtent_cy(R\R]RkRR2(((s&code\common\utils\third_party\pyemf.pyRs t_SETWINDOWORGEXcBs)eZdZddgZdddZRS(i RYt ptlOrigin_xt ptlOrigin_yicCs#tj|||_||_dS(N(RuR2RR(R/RR((s&code\common\utils\third_party\pyemf.pyR2s  (RYs ptlOrigin_x(RYs ptlOrigin_y(R\R]RkRR2(((s&code\common\utils\third_party\pyemf.pyRs t_SETVIEWPORTEXTEXcBseZdZRS(i (R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRst_SETVIEWPORTORGEXcBseZdZRS(i (R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRst_SETBRUSHORGEXcBseZdZRS(i (R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRst_EOFcBs,eZdZdZdd d gZdZRS( sEnd of file marker. Usually 20 bytes long, but I have a Windows generated .emf file that only has a 12 byte long EOF record. I don't know if that's a broken example or what, but both Windows progs and OpenOffice seem to handle it.iRYRit offPalEntriest nSizeLastcCstj|dS(N(RuR2(R/((s&code\common\utils\third_party\pyemf.pyR2s(RYs nPalEntriesi(RYRi(RYRi(R\R]R^RkRR2(((s&code\common\utils\third_party\pyemf.pyRs  t _SETPIXELVcBs/eZdZddd gZddddZRS( iRYt ptlPixel_xt ptlPixel_ytcrColoricCs,tj|||_||_||_dS(N(RuR2RRR(R/RRtcolor((s&code\common\utils\third_party\pyemf.pyR2s   (RYs ptlPixel_x(RYs ptlPixel_y(RYscrColor(R\R]RkRR2(((s&code\common\utils\third_party\pyemf.pyRs  t_SETMAPPERFLAGScBs eZdZdgZdZRS(iRYtdwFlagsicCstj|dS(N(RuR2(R/((s&code\common\utils\third_party\pyemf.pyR2$s(RYRi(R\R]Rkt emr_formatR2(((s&code\common\utils\third_party\pyemf.pyR s t _SETMAPMODEcBs2eZdZddefgZededZRS(iRYtiModeicCs>tj|||ks%||kr1d|_n ||_dS(Ni(RuR2RR(R/tmodetfirsttlast((s&code\common\utils\third_party\pyemf.pyR2,s  (R\R]RktMM_ANISOTROPICRtMM_MAXR2(((s&code\common\utils\third_party\pyemf.pyR(st _SETBKMODEcBseZdZedZRS(icCstjj||dtdS(NR(RRR2t BKMODE_LAST(R/R((s&code\common\utils\third_party\pyemf.pyR25s(R\R]RktOPAQUER2(((s&code\common\utils\third_party\pyemf.pyR3st_SETPOLYFILLMODEcBseZdZedZRS(icCstjj||dtdS(NR(RRR2t POLYFILL_LAST(R/R((s&code\common\utils\third_party\pyemf.pyR2;s(R\R]Rkt ALTERNATER2(((s&code\common\utils\third_party\pyemf.pyR9st_SETROP2cBseZdZRS(i(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyR ?st_SETSTRETCHBLTMODEcBseZdZRS(i(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyR Dst _SETTEXTALIGNcBseZdZedZRS(icCstjj||dtdS(NR(RRR2tTA_MASK(R/R((s&code\common\utils\third_party\pyemf.pyR2Ks(R\R]Rkt TA_BASELINER2(((s&code\common\utils\third_party\pyemf.pyR Ist _SETTEXTCOLORcBs#eZdZdgZddZRS(iRYRicCstj|||_dS(N(RuR2R(R/R((s&code\common\utils\third_party\pyemf.pyR2Us (RYscrColori(R\R]RkRR2(((s&code\common\utils\third_party\pyemf.pyRQs t _SETBKCOLORcBseZdZRS(i(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRZst _MOVETOEXcBs2eZdZddgZdddZdZRS( iRYtptl_xtptl_yicCs#tj|||_||_dS(N(RuR2RR(R/RR((s&code\common\utils\third_party\pyemf.pyR2hs  cCs|j|j|j|jfS(N(RR(R/((s&code\common\utils\third_party\pyemf.pyRBms(RYsptl_x(RYsptl_y(R\R]RkRR2RB(((s&code\common\utils\third_party\pyemf.pyRbs  t_SCALEVIEWPORTEXTEXcBs5eZdZdd d d gZdddddZRS( iRYtxNumitxDenomtyNumtyDenomcCs5tj|||_||_||_||_dS(N(RuR2RRRR(R/txntxdtyntyd((s&code\common\utils\third_party\pyemf.pyR2}s     (RYsxNumi(RYsxDenomi(RYsyNumi(RYsyDenomi(R\R]RkRR2(((s&code\common\utils\third_party\pyemf.pyRus  t_SCALEWINDOWEXTEXcBseZdZRS(i (R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRst_SAVEDCcBseZdZRS(i!(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRst _RESTOREDCcBs#eZdZdgZddZRS(i"RYt iRelativeicCstj|||_dS(N(RuR2R!(R/trel((s&code\common\utils\third_party\pyemf.pyR2s (RYs iRelative(R\R]RkRR2(((s&code\common\utils\third_party\pyemf.pyR s t_SETWORLDTRANSFORMcBsAeZdZd d d dddgZdd d dd d d ZRS(i#RteM11teM12teM21teM22teDxteDyg?gcCsGtj|||_||_||_||_||_||_dS(N(RuR2R$R%R&R'R(R)(R/tem11tem12tem21tem22tedxtedy((s&code\common\utils\third_party\pyemf.pyR2s      (RseM11(RseM12(RseM21(RseM22(RseDx(RseDy(R\R]RkRR2(((s&code\common\utils\third_party\pyemf.pyR#s t_MODIFYWORLDTRANSFORMcBsGeZdZd ddddddgZd d d d d d ed ZRS(i$RR$R%R&R'R(R)RYRg?gcCsPtj|||_||_||_||_||_||_||_dS(N( RuR2R$R%R&R'R(R)R(R/R*R+R,R-R.R/R((s&code\common\utils\third_party\pyemf.pyR2s       (RseM11(RseM12(RseM21(RseM22(RseDx(RseDy(RYsiMode(R\R]RkRt MWT_IDENTITYR2(((s&code\common\utils\third_party\pyemf.pyR0s t _SELECTOBJECTcBs,eZdZdZdgZdddZRS(s!Select a brush, pen, font (or bitmap or region but there is no current user interface for those) object to be current and replace the previous item of that class. Note that stock objects have their high order bit set, so the handle must be an unsigned int.i%tIRRicCstj|||_dS(N(RuR2RR(R/RRR((s&code\common\utils\third_party\pyemf.pyR2s (R3shandleN(R\R]R^RkRRR2(((s&code\common\utils\third_party\pyemf.pyR2s t _CREATEPENcBs>eZdZd d d ddgZeddd Zd ZRS(i&RYRRit lopn_stylet lopn_widtht lopn_unusedt lopn_coloricCs,tj|||_||_||_dS(N(RuR2R5R6R8(R/tstyleR R((s&code\common\utils\third_party\pyemf.pyR2s   cCstS(N(tTrue(R/((s&code\common\utils\third_party\pyemf.pyRs(RYshandlei(RYs lopn_style(RYs lopn_width(RYR7i(RYs lopn_color(R\R]RkRtPS_SOLIDR2R(((s&code\common\utils\third_party\pyemf.pyR4s t_CREATEBRUSHINDIRECTcBs;eZdZd d d d gZeeddZd ZRS(i'RYRRiR3tlbStyletlbColortlbHatchcCs,tj|||_||_||_dS(N(RuR2R=R>R?(R/R9thatchR((s&code\common\utils\third_party\pyemf.pyR2s   cCstS(N(R:(R/((s&code\common\utils\third_party\pyemf.pyRs(RYshandlei(R3slbStyle(RYslbColor(R3slbHatch(R\R]RkRtBS_SOLIDt HS_HORIZONTALR2R(((s&code\common\utils\third_party\pyemf.pyR<s t _DELETEOBJECTcBseZdZRS(i((R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRCst _ANGLEARCcBs,eZdZd d d d d gZdZRS(i)RYt ptlCenter_xt ptlCenter_ytnRadiusRt eStartAnglet eSweepAnglecCstj|dS(N(RuR2(R/((s&code\common\utils\third_party\pyemf.pyR2s(RYRE(RYRF(RYRG(RRH(RRI(R\R]RkRR2(((s&code\common\utils\third_party\pyemf.pyRDs t_ELLIPSEcBs,eZdZdd d d gZd dZRS( i*RYt rclBox_leftt rclBox_topt rclBox_rightt rclBox_bottomicCsEtj||d|_|d|_|d|_|d|_dS(Niiii(RuR2RKRLRMRN(R/tbox((s&code\common\utils\third_party\pyemf.pyR2s     (RYs rclBox_left(RYs rclBox_top(RYs rclBox_right(RYs rclBox_bottom(iiii(R\R]RkRR2(((s&code\common\utils\third_party\pyemf.pyRJs  t _RECTANGLEcBseZdZRS(i+(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRPst _ROUNDRECTcBs8eZdZd d d d ddgZdddd ZRS(i,RYRKRLRMRNt szlCorner_cxt szlCorner_cyicCsWtj||d|_|d|_|d|_|d|_||_||_dS(Niiii(RuR2RKRLRMRNRRRS(R/RORR((s&code\common\utils\third_party\pyemf.pyR2%s      (RYs rclBox_left(RYs rclBox_top(RYs rclBox_right(RYs rclBox_bottom(RYs szlCorner_cx(RYs szlCorner_cy(iiii(R\R]RkRR2(((s&code\common\utils\third_party\pyemf.pyRQs t_ARCc BsMeZdZd d ddddddgZd d d d d d d d d ZRS(i-RYRKRLRMRNt ptlStart_xt ptlStart_ytptlEnd_xtptlEnd_yic CsYtj|||_||_||_||_||_||_||_||_ dS(N( RuR2RKRLRMRNRURVRWRX( R/RGRHRIRJtxstarttystarttxendtyend((s&code\common\utils\third_party\pyemf.pyR2;s        (RYs rclBox_left(RYs rclBox_top(RYs rclBox_right(RYs rclBox_bottom(RYs ptlStart_x(RYs ptlStart_y(RYsptlEnd_x(RYsptlEnd_y(R\R]RkRR2(((s&code\common\utils\third_party\pyemf.pyRT/s  t_CHORDcBseZdZRS(i.(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyR]Hst_PIEcBseZdZRS(i/(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyR^Mst_SELECTPALETTEcBs eZdZdgZdZRS(i0RYRRcCstj|dS(N(RuR2(R/((s&code\common\utils\third_party\pyemf.pyR2Vs(RYshandle(R\R]RkRR2(((s&code\common\utils\third_party\pyemf.pyR_Rs t_CREATEPALETTEcBs)eZdZdgZdZdZRS(i1RYRRicCstj|dS(N(RuR2(R/((s&code\common\utils\third_party\pyemf.pyR2_scCstS(N(R:(R/((s&code\common\utils\third_party\pyemf.pyRbs(RYshandlei(R\R]RkRR2R(((s&code\common\utils\third_party\pyemf.pyR`[s  t_LINETOcBseZdZRS(i6(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRalst_ARCTOcBseZdZdZRS(i7cCs|j|j|j|jfS(N(RKRLRMRN(R/((s&code\common\utils\third_party\pyemf.pyRBts (R\R]RkRB(((s&code\common\utils\third_party\pyemf.pyRbqst_SETARCDIRECTIONcBs eZdZdgZdZRS(i9RYt iArcDirectioncCstj|dS(N(RuR2(R/((s&code\common\utils\third_party\pyemf.pyR2s(RYRd(R\R]RkRR2(((s&code\common\utils\third_party\pyemf.pyRcs t _BEGINPATHcBseZdZRS(i;(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRest_ENDPATHcBseZdZRS(i<(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRfst _CLOSEFIGUREcBseZdZRS(i=(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRgst _FILLPATHcBs,eZdZdd d d gZd dZRS( i>RYR;R<R=R>icCstj||j|dS(N(RuR2R(R/R((s&code\common\utils\third_party\pyemf.pyR2s (RYsrclBounds_left(RYs rclBounds_top(RYsrclBounds_right(RYsrclBounds_bottom(iiii(R\R]RkRR2(((s&code\common\utils\third_party\pyemf.pyRhs  t_STROKEANDFILLPATHcBseZdZRS(i?(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRist _STROKEPATHcBseZdZRS(i@(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRjst _FLATTENPATHcBseZdZRS(iA(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRkst _WIDENPATHcBseZdZRS(iB(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRlst_SELECTCLIPPATHcBs eZdZdZedZRS(s~Select the current path and make it the clipping region. Must be a closed path. @gdi: SelectClipPath iCcCs#tjj||dtdtdS(NRR(RRR2tRGN_MINtRGN_MAX(R/R((s&code\common\utils\third_party\pyemf.pyR2s(R\R]R^RktRGN_COPYR2(((s&code\common\utils\third_party\pyemf.pyRmst _ABORTPATHcBseZdZdZRS(sKDiscards any current path, whether open or closed. @gdi: AbortPathiD(R\R]R^Rk(((s&code\common\utils\third_party\pyemf.pyRqst_STRETCHDIBITScBsYeZdZdZddddddddddd d!d"d#d$d%d&d'gZdZRS((sCopies the image from the source image to the destination image. DIB is currently an opaque format to me, but apparently it has been extented recently to allow JPG and PNG images... @gdi: StretchDIBits iQRYR;R<R=R>txDesttyDesttxSrctySrctcxSrctcySrct offBmiSrctcbBmiSrct offBitsSrct cbBitsSrct iUsageSrctdwRoptcxDesttcyDestcCstj|dS(N(RuR2(R/((s&code\common\utils\third_party\pyemf.pyR2s(RYsrclBounds_left(RYs rclBounds_top(RYsrclBounds_right(RYsrclBounds_bottom(RYsxDest(RYsyDest(RYsxSrc(RYsySrc(RYscxSrc(RYscySrc(RYs offBmiSrc(RYscbBmiSrc(RYs offBitsSrc(RYs cbBitsSrc(RYs iUsageSrc(RYsdwRop(RYscxDest(RYscyDest(R\R]R^RkRR2(((s&code\common\utils\third_party\pyemf.pyRrs* t_EXTCREATEFONTINDIRECTWc#BseZdZd.d/d0d1d2d3d4d5d6d7d8d9d:d;d<ddddfddddfd=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLg!Zddddedddeeeee e Bd+d,Z d-Z RS(MiRRYRRtlfHeighttlfWidtht lfEscapementt lfOrientationtlfWeighttBtlfItalict lfUnderlinet lfStrikeOutt lfCharSettlfOutPrecisiontlfClipPrecisiont lfQualitytlfPitchAndFamilyt64st lfFaceNamet128st elfFullNameRvitelfStylei@t elfVersionit elfStyleSizetelfMatcht elfReservedt elfVendorIdt elfCulturetelfPanose_bFamilyTypeitelfPanose_bSerifStyletelfPanose_bWeighttelfPanose_bProportiontelfPanose_bContrasttelfPanose_bStrokeVariationtelfPanose_bArmStyletelfPanose_bLetterformtelfPanose_bMidlinetelfPanose_bXHeightsTimes New RomancCstj|||_||_||_||_||_||_||_||_ | |_ | |_ | |_ | |_ | |_tj|_t|dkr|dd!}n|ddt|7}|jdjd|_dS(Ni iRvsutf-8sutf-16le(RuR2RRRRRRRRRRRRRRR}RORRR(R/R!R t escapementt orientationtweighttitalict underlinet strike_outtcharsett out_precisiontclip_precisiontqualityt pitch_familyRt((s&code\common\utils\third_party\pyemf.pyR2"s&               cCstS(N(R:(R/((s&code\common\utils\third_party\pyemf.pyRBs(RYshandle(RYslfHeight(RYslfWidth(RYs lfEscapement(RYs lfOrientation(RYslfWeight(RslfItalic(Rs lfUnderline(Rs lfStrikeOut(Rs lfCharSet(RslfOutPrecision(RslfClipPrecision(Rs lfQuality(RslfPitchAndFamily(Rs lfFaceName(RYRi(RYRi(RYRi(RYRi(RYRi(RYRi(RRi(RRi(RRi(RRi(RRi(RRi(RRi(RRi(RRi(RRi( R\R]RkRt FW_NORMALt ANSI_CHARSETtOUT_DEFAULT_PRECIStCLIP_DEFAULT_PRECIStDEFAULT_QUALITYt DEFAULT_PITCHt FF_DONTCARER2R(((s&code\common\utils\third_party\pyemf.pyRsR   t _EXTTEXTOUTAcBseZdZdddd ddefd!d"d#d$d%d&d'd(d)d*d+d,gZddddZdZdZdZdZ RS(-iSRYR;iR<R=iR>t iGraphicsModeRtexScaleg?teyScaletptlReference_xtptlReference_ytnCharst offStringtfOptionstrcl_lefttrcl_topt rcl_rightt rcl_bottomtoffDxRcCsbtj|||_||_t|trC|jd|_n ||_d|_g|_ dS(Nsutf-16lei( RuR2RRRRRtstringtcharsizetdx(R/RRR((s&code\common\utils\third_party\pyemf.pyR2Zs     cCsd}|jdkrN|j|j}|jd|j||\}|_n g|_|jdkr|j|j}||||j|j!|_n d|_dS(NiRYR(RRRRRRRR(R/R|R((s&code\common\utils\third_party\pyemf.pyRes' !cCs|j}d}d}t|jdkrrt|j|j|_||_t|j|j}||7}nt|jdkr||_t j d|j}||7}n||S(NiRY( RRORRRRRRRRoRp(R/RtsizedxR((s&code\common\utils\third_party\pyemf.pyRys     cCsQ|jdkr%|j||jn|jdkrM|j|d|jndS(NiRY(RRRRRR(R/R((s&code\common\utils\third_party\pyemf.pyRscCs|t}|jdt|j|jdkrX|jdt|jjdn|jdt|j|jS(Ns dx: %s is unicode string: %s sutf-16les ascii string: %s (RRRlRRRRR(R/R((s&code\common\utils\third_party\pyemf.pyRs  &(RYsrclBounds_lefti(RYs rclBounds_topi(RYsrclBounds_righti(RYsrclBounds_bottomi(RRg?(RRg?(RYsptlReference_x(RYsptlReference_y(RYsnChars(RYs offString(RYRi(RYRi(RYRi(RYRi(RYRi(RYsoffDxi( R\R]Rkt GM_COMPATIBLERR2RRRR(((s&code\common\utils\third_party\pyemf.pyRFs.     t _EXTTEXTOUTWcBs eZdZddddZRS(iTiucCs&tjj||||d|_dS(Ni(RRR2R(R/RRR((s&code\common\utils\third_party\pyemf.pyR2s(R\R]RkR2(((s&code\common\utils\third_party\pyemf.pyRst _POLYBEZIER16cBseZdZdZRS(iUR(R\R]RkR(((s&code\common\utils\third_party\pyemf.pyRst _POLYGON16cBseZdZRS(iV(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRst _POLYLINE16cBseZdZRS(iW(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRst_POLYBEZIERTO16cBseZdZdZRS(iXR(R\R]RkR(((s&code\common\utils\third_party\pyemf.pyRst _POLYLINETO16cBseZdZRS(iY(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRst_POLYPOLYLINE16cBseZdZdZRS(iZR(R\R]RkR(((s&code\common\utils\third_party\pyemf.pyRst_POLYPOLYGON16cBseZdZRS(i[(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRst_CREATEMONOBRUSHcBseZdZRS(i](R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRst_CREATEDIBPATTERNBRUSHPTcBseZdZRS(i^(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRst _EXTCREATEPENcBseZdZRS(i_(R\R]Rk(((s&code\common\utils\third_party\pyemf.pyRst _SETICMMODEcBs eZdZdZedZRS(sRSet or query the current color management mode. @gdi: SetICMMode ibcCs#tjj||dtdtdS(NRR(RRR2tICM_MINtICM_MAX(R/R((s&code\common\utils\third_party\pyemf.pyR2s(R\R]R^RktICM_OFFR2(((s&code\common\utils\third_party\pyemf.pyRs(KR\R]RuRRRRRRRRRRRRRRRRRRRR R R RRRRRRR R#R0R2R4R<RCRDRJRPRQRTR]R^R_R`RaRbRcReRfRgRhRiRjRkRlRmRqRrRRRRRRRRRRRRRR(((s&code\common\utils\third_party\pyemf.pyRsr$.          !LW  tEMFcBseZdZdddddedZdNdZdZd Zd Z dNd Z d Z d Z dZ dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZd Zd!Z d"Z!d#Z"d$Z#d%Z$d&Z%d'Z&d(Z'd)d*d*d)d*d*d+Z(d)d*d*d)d*d*d,Z)d-Z*d.Z+d/Z,d0Z-d1Z.d2Z/d3Z0d4Z1d5Z2d6Z3d7Z4d8Z5d9Z6d:Z7d;Z8d<Z9d=Z:d>Z;d?Z<d@Z=dAZ>dBZ?dCZ@eAdDZBdEZCdFZDdGZEdHZFdIdIdIeGdIdIdIeHeIeJeKdJdKdL ZLdMZMRS(Os  Reference page of the public API for enhanced metafile creation. See L{pyemf} for an overview / mini tutorial. @group Creating Metafiles: __init__, load, save @group Drawing Parameters: GetStockObject, SelectObject, DeleteObject, CreatePen, CreateSolidBrush, CreateHatchBrush, SetBkColor, SetBkMode, SetPolyFillMode @group Drawing Primitives: SetPixel, Polyline, PolyPolyline, Polygon, PolyPolygon, Rectangle, RoundRect, Ellipse, Arc, Chord, Pie, PolyBezier @group Path Primatives: BeginPath, EndPath, MoveTo, LineTo, PolylineTo, ArcTo, PolyBezierTo, CloseFigure, FillPath, StrokePath, StrokeAndFillPath @group Clipping: SelectClipPath @group Text: CreateFont, SetTextAlign, SetTextColor, TextOut @group Coordinate System Transformation: SaveDC, RestoreDC, SetWorldTransform, ModifyWorldTransform @group **Experimental** -- Viewport Manipulation: SetMapMode, SetViewportOrgEx, GetViewportOrgEx, SetWindowOrgEx, GetWindowOrgEx, SetViewportExtEx, ScaleViewportExtEx, GetViewportExtEx, SetWindowExtEx, ScaleWindowExtEx, GetWindowExtEx g@g@i,Rs pyemf.sf.netcCsd|_t|||||_g|_d|_||_t|_t j |}|j ||js|j t |j|jj|jj|jt|jjd|jj|jjt|jjd|jj|jjndS(s Create an EMF structure in memory. The size of the resulting image is specified in either inches or millimeters depending on the value of L{units}. Width and height are floating point values, but density must be an integer because this becomes the basis for the coordinate system in the image. Density is the number of individually addressible pixels per unit measurement (dots per inch or dots per millimeter, depending on the units system) in the image. A consequence of this is that each pixel is specified by a pair of integer coordinates. @param width: width of EMF image in inches or millimeters @param height: height of EMF image in inches or millimeters @param density: dots (pixels) per unit measurement @param units: string indicating the unit measurement, one of: - 'in' - 'mm' @type width: float @type height: float @type density: int @type units: string @param description: optional string to specify a description of the image @type description: string igY@N(RtfilenameRRtrecordst pathstartRzR:RRRt_appendt SetMapModeRtSetWindowExtExR#R$tSetViewportExtExRR RRR!RR(R/R R!R0R1RRzRQ((s&code\common\utils\third_party\pyemf.pyR2s        'cCsg|r||_n|jrct|j}g|_|j|t|_|jj|jdndS(s Read an existing EMF file. If any records exist in the current object, they will be overwritten by the records from this file. @param filename: filename to load @type filename: string @returns: True for success, False for failure. @rtype: Boolean iN(RtopenRt _unserializeRVRRRB(R/RR((s&code\common\utils\third_party\pyemf.pytloadOs      cCs<y$d}x|dkr"|jd}t|}|dkr tjd|\}}|jrrd||fGHn|tkrt|}n t}|j||||jj ||j r|j j ||j n(t|tjr|j j|j n|jrdG|GHqq q WWntk r7nXdS(Niiis} of the new pen. @return: handle to the new pen graphics object. @rtype: int @type style: int @type width: int @type color: int (RRR4R(R/R9R R((s&code\common\utils\third_party\pyemf.pyt CreatePenh scCs|jtjdt|S(s Create a solid brush used to fill polygons. @param color: the L{color} of the solid brush. @return: handle to brush graphics object. @rtype: int @type color: int R(RRR<R(R/R((s&code\common\utils\third_party\pyemf.pytCreateSolidBrush s cCs%|jtjd|dt|S(s Create a hatched brush used to fill polygons. B{Note:} Currently appears unsupported in OpenOffice. @param hatch: integer representing type of fill: - HS_HORIZONTAL - HS_VERTICAL - HS_FDIAGONAL - HS_BDIAGONAL - HS_CROSS - HS_DIAGCROSS @type hatch: int @param color: the L{color} of the 'on' pixels of the brush. @return: handle to brush graphics object. @rtype: int @type color: int R@R(RRR<R(R/R@R((s&code\common\utils\third_party\pyemf.pytCreateHatchBrush scCs,tjt|}|j|s(dSdS(s Set the background color used for any transparent regions in fills or hatched brushes. B{Note:} Currently appears sporadically supported in OpenOffice. @param color: background L{color}. @return: previous background L{color}. @rtype: int @type color: int ii(RRRR(R/RR((s&code\common\utils\third_party\pyemf.pyt SetBkColor scCs&tj|}|j|s"dSdS(sX Set the background mode for interaction between transparent areas in the region to be drawn and the existing background. The choices for mode are: - TRANSPARENT - OPAQUE B{Note:} Currently appears sporadically supported in OpenOffice. @param mode: background mode. @return: previous background mode. @rtype: int @type mode: int ii(RRR(R/RR((s&code\common\utils\third_party\pyemf.pyt SetBkMode scCs&tj|}|j|s"dSdS(s Set the polygon fill mode. Generally these modes produce different results only when the edges of the polygons overlap other edges. @param mode: fill mode with the following options: - ALTERNATE - fills area between odd and even numbered sides - WINDING - fills all area as long as a point is between any two sides @return: previous fill mode. @rtype: int @type mode: int ii(RRR(R/RR((s&code\common\utils\third_party\pyemf.pytSetPolyFillMode scCs&tj|}|j|s"dSdS(ss Set the window mapping mode. This is the mapping between pixels in page space to pixels in device space. Page space is the coordinate system that is used for all the drawing commands -- it is how pixels are identified and figures are placed in the metafile. They are integer units. Device space is the coordinate system of the final output, measured in physical dimensions such as mm, inches, or twips. It is this coordinate system that provides the scaling that makes metafiles into a scalable graphics format. - MM_TEXT: each unit in page space is mapped to one pixel - MM_LOMETRIC: 1 page unit = .1 mm in device space - MM_HIMETRIC: 1 page unit = .01 mm in device space - MM_LOENGLISH: 1 page unit = .01 inch in device space - MM_HIENGLISH: 1 page unit = .001 inch in device space - MM_TWIPS: 1 page unit = 1/20 point (or 1/1440 inch) - MM_ISOTROPIC: 1 page unit = user defined ratio, but axes equally scaled - MM_ANISOTROPIC: 1 page unit = user defined ratio, axes may be independently scaled @param mode: window mapping mode. @return: previous window mapping mode, or zero if error. @rtype: int @type mode: int ii(RRR(R/RR((s&code\common\utils\third_party\pyemf.pyR scCsYtj||}|j|s%dS|jj|jjf}||j_||j_|S(s Set the origin of the viewport, which translates the origin of the coordinate system by (xv,yv). A pixel drawn at (x,y) in the new coordinate system will be displayed at (x+xv,y+yv) in terms of the previous coordinate system. Contrast this with L{SetWindowOrgEx}, which seems to be the opposite translation. So, if in addition, the window origin is set to (xw,yw) using L{SetWindowOrgEx}, a pixel drawn at (x,y) will be displayed at (x-xw+xv,y-yw+yv) in terms of the original coordinate system. @param xv: new x position of the viewport origin. @param yv: new y position of the viewport origin. @return: previous viewport origin @rtype: 2-tuple (x,y) if successful, or None if unsuccessful @type xv: int @type yv: int N(RRRRRR'R((R/txvtyvRtold((s&code\common\utils\third_party\pyemf.pytSetViewportOrgEx s  cCs|jj|jjfS(sn Get the origin of the viewport. @return: returns the current viewport origin. @rtype: 2-tuple (x,y) (RR'R((R/((s&code\common\utils\third_party\pyemf.pytGetViewportOrgEx scCsYtj||}|j|s%dS|jj|jjf}||j_||j_|S(s Set the origin of the window, which translates the origin of the coordinate system by (-xw,-yw). A pixel drawn at (x,y) in the new coordinate system will be displayed at (x-xw,y-yw) in terms of the previous coordinate system. Contrast this with L{SetViewportOrgEx}, which seems to be the opposite translation. So, if in addition, the viewport origin is set to (xv,yv) using L{SetViewportOrgEx}, a pixel drawn at (x,y) will be displayed at (x-xw+xv,y-yw+yv) in terms of the original coordinate system. @param xw: new x position of the window origin. @param yw: new y position of the window origin. @return: previous window origin @rtype: 2-tuple (x,y) if successful, or None if unsuccessful @type xw: int @type yw: int N(RRRRRR+R,(R/txwtywRR ((s&code\common\utils\third_party\pyemf.pytSetWindowOrgEx% s  cCs|jj|jjfS(sl Get the origin of the window. @return: returns the current window origin. @rtype: 2-tuple (x,y) (RR+R,(R/((s&code\common\utils\third_party\pyemf.pytGetWindowOrgExB scCsYtj||}|j|s%dS|jj|jjf}t|j_t|j_|S(s/ Set the dimensions of the viewport in device units. Device units are physical dimensions, in millimeters. The total extent is equal to the width is millimeters multiplied by the density of pixels per millimeter in that dimension. Note: this is only usable when L{SetMapMode} has been set to MM_ISOTROPIC or MM_ANISOTROPIC. @param x: new width of the viewport. @param y: new height of the viewport. @return: returns the previous size of the viewport. @rtype: 2-tuple (width,height) if successful, or None if unsuccessful @type x: int @type y: int N( RRRRRR)R*R R (R/RRRR ((s&code\common\utils\third_party\pyemf.pyRL s  cCsztjj||||}|j|s.dS|jj|jjf}|d|||j_|d|||j_|S(s~ Scale the dimensions of the viewport. @param x_num: numerator of x scale @param x_den: denominator of x scale @param y_num: numerator of y scale @param y_den: denominator of y scale @return: returns the previous size of the viewport. @rtype: 2-tuple (width,height) if successful, or None if unsuccessful @type x_num: int @type x_den: int @type y_num: int @type y_den: int iiN(RRRRRR)R*(R/tx_numtx_denty_numty_denRR ((s&code\common\utils\third_party\pyemf.pytScaleViewportExtExe scCs|jj|jjf}|S(s Get the dimensions of the viewport in device units (i.e. physical dimensions). @return: returns the size of the viewport. @rtype: 2-tuple (width,height) (RR)R*(R/R ((s&code\common\utils\third_party\pyemf.pytGetViewportExtEx| scCsYtj||}|j|s%dS|jj|jjf}||j_||j_|S(s Set the dimensions of the window. Window size is measured in integer numbers of pixels (logical units). Note: this is only usable when L{SetMapMode} has been set to MM_ISOTROPIC or MM_ANISOTROPIC. @param x: new width of the window. @param y: new height of the window. @return: returns the previous size of the window. @rtype: 2-tuple (width,height) if successful, or None if unsuccessful @type x: int @type y: int N(RRRRRR-R.(R/RRRR ((s&code\common\utils\third_party\pyemf.pyR s  cCswtj||||}|j|s+dS|jj|jjf}|d|||j_|d|||j_|S(sz Scale the dimensions of the window. @param x_num: numerator of x scale @param x_den: denominator of x scale @param y_num: numerator of y scale @param y_den: denominator of y scale @return: returns the previous size of the window. @rtype: 2-tuple (width,height) if successful, or None if unsuccessful @type x_num: int @type x_den: int @type y_num: int @type y_den: int iiN(RRRRRR-R.(R/RRRRRR ((s&code\common\utils\third_party\pyemf.pytScaleWindowExtEx scCs|jj|jjf}|S(s Get the dimensions of the window in logical units (integer numbers of pixels). @return: returns the size of the window. @rtype: 2-tuple (width,height) (RR-R.(R/R ((s&code\common\utils\third_party\pyemf.pytGetWindowExtEx sg?gcCs%|jtj||||||S(s Set the world coordinate to logical coordinate linear transform for subsequent operations. With this matrix operation, you can translate, rotate, scale, shear, or a combination of all four. The matrix operation is defined as follows where (x,y) are the original coordinates and (x',y') are the transformed coordinates:: | x | | m11 m12 0 | | x' | | y | * | m21 m22 0 | = | y' | | 0 | | dx dy 1 | | 0 | or, the same thing defined as a system of linear equations:: x' = x*m11 + y*m21 + dx y' = x*m12 + y*m22 + dy http://msdn.microsoft.com/library/en-us/gdi/cordspac_0inn.asp says that the offsets are in device coordinates, not pixel coordinates. B{Note:} Currently partially supported in OpenOffice. @param m11: matrix entry @type m11: float @param m12: matrix entry @type m12: float @param m21: matrix entry @type m21: float @param m22: matrix entry @type m22: float @param dx: x shift @type dx: float @param dy: y shift @type dy: float @return: status @rtype: boolean (RRR#(R/tm11tm12tm21tm22Rtdy((s&code\common\utils\third_party\pyemf.pytSetWorldTransform s'c Cs(|jtj|||||||S(s Change the current linear transform. See L{SetWorldTransform} for a description of the matrix parameters. The new transform may be modified in one of three ways, set by the mode parameter: - MWT_IDENTITY: reset the transform to the identity matrix (the matrix parameters are ignored). - MWT_LEFTMULTIPLY: multiply the matrix represented by these parameters by the current world transform to get the new transform. - MWT_RIGHTMULTIPLY: multiply the current world tranform by the matrix represented here to get the new transform. The reason that there are two different multiplication types is that matrix multiplication is not commutative, which means the order of multiplication makes a difference. B{Note:} The parameter order was changed from GDI standard so that I could make the matrix parameters optional in the case of MWT_IDENTITY. B{Note:} Currently appears unsupported in OpenOffice. @param mode: MWT_IDENTITY, MWT_LEFTMULTIPLY, or MWT_RIGHTMULTIPLY @type mode: int @param m11: matrix entry @type m11: float @param m12: matrix entry @type m12: float @param m21: matrix entry @type m21: float @param m22: matrix entry @type m22: float @param dx: x shift @type dx: float @param dy: y shift @type dy: float @return: status @rtype: boolean (RRR0(R/RRRRRRR((s&code\common\utils\third_party\pyemf.pytModifyWorldTransform s%cCs"|jtj||t|S(s Set the pixel to the given color. @param x: the horizontal position. @param y: the vertical position. @param color: the L{color} to set the pixel. @type x: int @type y: int @type color: int or (r,g,b) tuple (RRRR(R/RRR((s&code\common\utils\third_party\pyemf.pytSetPixel s cCs|j|tjtjS(s Draw a sequence of connected lines. @param points: list of x,y tuples @return: true if polyline is successfully rendered. @rtype: int @type points: tuple (RRRR(R/R((s&code\common\utils\third_party\pyemf.pytPolyline s cCs|j|tjtjS(s- Draw multiple polylines. The polylines argument is a list of lists, where each inner list represents a single polyline. Each polyline is described by a list of x,y tuples as in L{Polyline}. For example:: lines=[[(100,100),(200,100)], [(300,100),(400,100)]] emf.PolyPolyline(lines) draws two lines, one from 100,100 to 200,100, and another from 300,100 to 400,100. @param polylines: list of lines, where each line is a list of x,y tuples @type polylines: list @return: true if polypolyline is successfully rendered. @rtype: int (RRRR(R/t polylines((s&code\common\utils\third_party\pyemf.pyt PolyPolyline- sc Cst|dkr|dd|ddkr|dd|ddkr|dd|ddkr|dd|ddkr|jrdGHn|j|dd|dd|dd|ddS|dd|ddkr|dd|ddkr|dd|ddkr|dd|ddkr|jrJdGHn|j|dd|dd|dd|ddSn|j|tjtjS(sJ Draw a closed figure bounded by straight line segments. A polygon is defined by a list of points that define the endpoints for a series of connected straight line segments. The end of the last line segment is automatically connected to the beginning of the first line segment, the border is drawn with the current pen, and the interior is filled with the current brush. See L{SetPolyFillMode} for the fill effects when an overlapping polygon is defined. @param points: list of x,y tuples @return: true if polygon is successfully rendered. @rtype: int @type points: tuple iiiiis"converting to rectangle, option 1:s"converting to rectangle, option 2:(RORzt RectangleRRRR(R/R((s&code\common\utils\third_party\pyemf.pytPolygonD sp 6p 9cCs|j|tjtjS(s Draw multiple polygons. The polygons argument is a list of lists, where each inner list represents a single polygon. Each polygon is described by a list of x,y tuples as in L{Polygon}. For example:: lines=[[(100,100),(200,100),(200,200),(100,200)], [(300,100),(400,100),(400,200),(300,200)]] emf.PolyPolygon(lines) draws two squares. B{Note:} Currently partially supported in OpenOffice. The line width is ignored and the polygon border is not closed (the final point is not connected to the starting point in each polygon). @param polygons: list of polygons, where each polygon is a list of x,y tuples @type polygons: list @return: true if polypolygon is successfully rendered. @rtype: int (RRRR(R/tpolygons((s&code\common\utils\third_party\pyemf.pyt PolyPolygon_ scCs"|jtj||||fS(s Draw an ellipse using the current pen. @param left: x position of left side of ellipse bounding box. @param top: y position of top side of ellipse bounding box. @param right: x position of right edge of ellipse bounding box. @param bottom: y position of bottom edge of ellipse bounding box. @return: true if rectangle was successfully rendered. @rtype: int @type left: int @type top: int @type right: int @type bottom: int (RRRJ(R/RGRHRIRJ((s&code\common\utils\third_party\pyemf.pytEllipsey scCs"|jtj||||fS(s Draw a rectangle using the current pen. @param left: x position of left side of ellipse bounding box. @param top: y position of top side of ellipse bounding box. @param right: x position of right edge of ellipse bounding box. @param bottom: y position of bottom edge of ellipse bounding box. @return: true if rectangle was successfully rendered. @rtype: int @type left: int @type top: int @type right: int @type bottom: int (RRRP(R/RGRHRIRJ((s&code\common\utils\third_party\pyemf.pyR& scCs(|jtj||||||fS(sq Draw a rectangle with rounded corners using the current pen. @param left: x position of left side of ellipse bounding box. @param top: y position of top side of ellipse bounding box. @param right: x position of right edge of ellipse bounding box. @param bottom: y position of bottom edge of ellipse bounding box. @param cornerwidth: width of the ellipse that defines the roundness of the corner. @param cornerheight: height of ellipse @return: true if rectangle was successfully rendered. @rtype: int @type left: int @type top: int @type right: int @type bottom: int @type cornerwidth: int @type cornerheight: int (RRRQ(R/RGRHRIRJt cornerwidtht cornerheight((s&code\common\utils\third_party\pyemf.pyt RoundRect sc Cs+|jtj||||||||S(s Draw an arc of an ellipse. The ellipse is specified by its bounding rectange and two lines from its center to indicate the start and end angles. left, top, right, bottom describe the bounding rectangle of the ellipse. The start point given by xstart,ystert defines a ray from the center of the ellipse through the point and out to infinity. The point at which this ray intersects the ellipse is the starting point of the arc. Similarly, the infinite radial ray from the center through the end point defines the end point of the ellipse. The arc is drawn in a counterclockwise direction, and if the start and end rays are coincident, a complete ellipse is drawn. @param left: x position of left edge of arc box. @param top: y position of top edge of arc box. @param right: x position of right edge of arc box. @param bottom: y position bottom edge of arc box. @param xstart: x position of arc start. @param ystart: y position of arc start. @param xend: x position of arc end. @param yend: y position of arc end. @return: true if arc was successfully rendered. @rtype: int @type left: int @type top: int @type right: int @type bottom: int @type xstart: int @type ystart: int @type xend: int @type yend: int (RRRT( R/RGRHRIRJRYRZR[R\((s&code\common\utils\third_party\pyemf.pytArc s"c Cs+|jtj||||||||S(s Draw a chord of an ellipse. A chord is a closed region bounded by an arc and the [straight] line between the two points that define the arc start and end. The arc start and end points are defined as in L{Arc}. @param left: x position of left edge of arc box. @param top: y position of top edge of arc box. @param right: x position of right edge of arc box. @param bottom: y position bottom edge of arc box. @param xstart: x position of arc start. @param ystart: y position of arc start. @param xend: x position of arc end. @param yend: y position of arc end. @return: true if arc was successfully rendered. @rtype: int @type left: int @type top: int @type right: int @type bottom: int @type xstart: int @type ystart: int @type xend: int @type yend: int (RRR]( R/RGRHRIRJRYRZR[R\((s&code\common\utils\third_party\pyemf.pytChord sc Csg||kr6||kr6tj||||f} n$tj||||||||} |j| S(s Draw a pie slice of an ellipse. The ellipse is specified as in L{Arc}, and it is filled with the current brush. @param left: x position of left edge of arc box. @param top: y position of top edge of arc box. @param right: x position of right edge of arc box. @param bottom: y position bottom edge of arc box. @param xstart: x position of arc start. @param ystart: y position of arc start. @param xend: x position of arc end. @param yend: y position of arc end. @return: true if arc was successfully rendered. @rtype: int @type left: int @type top: int @type right: int @type bottom: int @type xstart: int @type ystart: int @type xend: int @type yend: int (RRJR^R( R/RGRHRIRJRYRZR[R\R((s&code\common\utils\third_party\pyemf.pytPie s$cCs|j|tjtjS(sS Draw cubic Bezier curves using the list of points as both endpoints and control points. The first point is used as the starting point, the second and thrird points are control points, and the fourth point is the end point of the first curve. Subsequent curves need three points each: two control points and an end point, as the ending point of the previous curve is used as the starting point for the next curve. @param points: list of x,y tuples that are either end points or control points @return: true if bezier curve was successfully rendered. @rtype: int @type points: tuple (RRRR(R/R((s&code\common\utils\third_party\pyemf.pyt PolyBezier scCs%t|j|_|jtjS(sw Begin defining a path. Any previous unclosed paths are discarded. @return: true if successful. @rtype: int (RORRRRRe(R/((s&code\common\utils\third_party\pyemf.pyt BeginPath, s cCs|jtjS(sM End the path definition. @return: true if successful. @rtype: int (RRRf(R/((s&code\common\utils\third_party\pyemf.pytEndPath8 scCs|jtj||S(s Move the current point to the given position and implicitly begin a new figure or path. @param x: new x position. @param y: new y position. @return: true if position successfully changed (can this fail?) @rtype: int @type x: int @type y: int (RRR(R/RR((s&code\common\utils\third_party\pyemf.pytMoveToB s cCs|jtj||S(s Draw a straight line using the current pen from the current point to the given position. @param x: x position of line end. @param y: y position of line end. @return: true if line is drawn (can this fail?) @rtype: int @type x: int @type y: int (RRRa(R/RR((s&code\common\utils\third_party\pyemf.pytLineToQ scCs|j|tjtjS(s Draw a sequence of connected lines starting from the current position and update the position to the final point in the list. @param points: list of x,y tuples @return: true if polyline is successfully rendered. @rtype: int @type points: tuple (RRRR(R/R((s&code\common\utils\third_party\pyemf.pyt PolylineToa s c Cs+|jtj||||||||S(s Draw an arc and update the current position. The arc is drawn as described in L{Arc}, but in addition the start of the arc will be connected to the previous position and the current position is updated to the end of the arc so subsequent path operations such as L{LineTo}, L{PolylineTo}, etc. will connect to the end. B{Note:} Currently appears unsupported in OpenOffice. @param left: x position of left edge of arc box. @param top: y position of top edge of arc box. @param right: x position of right edge of arc box. @param bottom: y position bottom edge of arc box. @param xstart: x position of arc start. @param ystart: y position of arc start. @param xend: x position of arc end. @param yend: y position of arc end. @return: true if arc was successfully rendered. @rtype: int @type left: int @type top: int @type right: int @type bottom: int @type xstart: int @type ystart: int @type xend: int @type yend: int (RRRb( R/RGRHRIRJRYRZR[R\((s&code\common\utils\third_party\pyemf.pytArcToo scCs|j|tjtjS(s Draw cubic Bezier curves, as described in L{PolyBezier}, but in addition draw a line from the previous position to the start of the curve. If the arc is successfully rendered, the current position is updated so that subsequent path operations such as L{LineTo}, L{PolylineTo}, etc. will follow from the end of the curve. @param points: list of x,y tuples that are either end points or control points @return: true if bezier curve was successfully rendered. @rtype: int @type points: tuple (RRRR(R/R((s&code\common\utils\third_party\pyemf.pyt PolyBezierTo scCs|jtjS(s Close a currently open path, which connects the current position to the starting position of a figure. Usually the starting position is the most recent call to L{MoveTo} after L{BeginPath}. @return: true if successful @rtype: int (RRRg(R/((s&code\common\utils\third_party\pyemf.pyt CloseFigure s cCs"|j}|jtj|S(s Close any currently open path and fills it using the currently selected brush and polygon fill mode. @return: true if successful. @rtype: int (RRRRh(R/R((s&code\common\utils\third_party\pyemf.pytFillPath s cCs"|j}|jtj|S(s Close any currently open path and outlines it using the currently selected pen. @return: true if successful. @rtype: int (RRRRj(R/R((s&code\common\utils\third_party\pyemf.pyt StrokePath s cCs"|j}|jtj|S(s Close any currently open path, outlines it using the currently selected pen, and fills it using the current brush. Same as stroking and filling using both the L{FillPath} and L{StrokePath} options, except that the pixels that would be in the overlap region to be both stroked and filled are optimized to be only stroked. B{Note:} Supported in OpenOffice 2.*, unsupported in OpenOffice 1.*. @return: true if successful. @rtype: int (RRRRi(R/R((s&code\common\utils\third_party\pyemf.pytStrokeAndFillPath s cCs|jtj|S(s Use the current path as the clipping path. The current path must be a closed path (i.e. with L{CloseFigure} and L{EndPath}) B{Note:} Currently unsupported in OpenOffice -- it apparently uses the bounding rectangle of the path as the clip area, not the path itself. @param mode: one of the following values that specifies how to modify the clipping path - RGN_AND: the new clipping path becomes the intersection of the old path and the current path - RGN_OR: the new clipping path becomes the union of the old path and the current path - RGN_XOR: the new clipping path becomes the union of the old path and the current path minus the intersection of the old and current path - RGN_DIFF: the new clipping path becomes the old path where any overlapping region of the current path is removed - RGN_COPY: the new clipping path is set to the current path and the old path is thrown away @return: true if successful. @rtype: int (RRRm(R/R((s&code\common\utils\third_party\pyemf.pytSelectClipPath scCs|jtjS(s Saves the current state of the graphics mode (such as line and fill styles, font, clipping path, drawing mode and any transformations) to a stack. This state can be restored by L{RestoreDC}. B{Note:} Currently unsupported in OpenOffice -- it apparently uses the bounding rectangle of the path as the clip area, not the path itself. @return: value of the saved state. @rtype: int (RRR(R/((s&code\common\utils\third_party\pyemf.pytSaveDC scCs|jtjdS(s Restores the state of the graphics mode to a stack. The L{stackid} parameter is either a value returned by L{SaveDC}, or if negative, is the number of states relative to the top of the save stack. For example, C{stackid == -1} is the most recently saved state. B{Note:} If the retrieved state is not at the top of the stack, any saved states above it are thrown away. B{Note:} Currently unsupported in OpenOffice -- it apparently uses the bounding rectangle of the path as the clip area, not the path itself. @param stackid: stack id number from L{SaveDC} or negative number for relative stack location @type stackid: int @return: nonzero for success @rtype: int i(RRR (R/tstackid((s&code\common\utils\third_party\pyemf.pyt RestoreDC scCs|jtj|S(s Set the subsequent alignment of drawn text. You can also pass a flag indicating whether or not to update the current point to the end of the text. Alignment may have the (sum of) values: - TA_NOUPDATECP - TA_UPDATECP - TA_LEFT - TA_RIGHT - TA_CENTER - TA_TOP - TA_BOTTOM - TA_BASELINE - TA_RTLREADING @param alignment: new text alignment. @return: previous text alignment value. @rtype: int @type alignment: int (RRR (R/t alignment((s&code\common\utils\third_party\pyemf.pyt SetTextAlign scCs,tjt|}|j|s(dSdS(s Set the text foreground color. @param color: text foreground L{color}. @return: previous text foreground L{color}. @rtype: int @type color: int ii(RRRR(R/RR((s&code\common\utils\third_party\pyemf.pyt SetTextColor- s isDEFAULT_PITCH|FF_DONTCAREsTimes New RomancCs=|jtj||||||||| | | | | |S(s Create a new font object. Presumably, when rendering the EMF the system tries to find a reasonable approximation to all the requested attributes. @param height: specified one of two ways: - if height>0: locate the font using the specified height as the typical cell height - if height<0: use the absolute value of the height as the typical glyph height. @param width: typical glyph width. If zero, the typical aspect ratio of the font is used. @param escapement: angle, in degrees*10, of rendered string rotation. Note that escapement and orientation must be the same. @param orientation: angle, in degrees*10, of rendered string rotation. Note that escapement and orientation must be the same. @param weight: weight has (at least) the following values: - FW_DONTCARE - FW_THIN - FW_EXTRALIGHT - FW_ULTRALIGHT - FW_LIGHT - FW_NORMAL - FW_REGULAR - FW_MEDIUM - FW_SEMIBOLD - FW_DEMIBOLD - FW_BOLD - FW_EXTRABOLD - FW_ULTRABOLD - FW_HEAVY - FW_BLACK @param italic: non-zero means try to find an italic version of the face. @param underline: non-zero means to underline the glyphs. @param strike_out: non-zero means to strike-out the glyphs. @param charset: select the character set from the following list: - ANSI_CHARSET - DEFAULT_CHARSET - SYMBOL_CHARSET - SHIFTJIS_CHARSET - HANGEUL_CHARSET - HANGUL_CHARSET - GB2312_CHARSET - CHINESEBIG5_CHARSET - GREEK_CHARSET - TURKISH_CHARSET - HEBREW_CHARSET - ARABIC_CHARSET - BALTIC_CHARSET - RUSSIAN_CHARSET - EE_CHARSET - EASTEUROPE_CHARSET - THAI_CHARSET - JOHAB_CHARSET - MAC_CHARSET - OEM_CHARSET @param out_precision: the precision of the face may have on of the following values: - OUT_DEFAULT_PRECIS - OUT_STRING_PRECIS - OUT_CHARACTER_PRECIS - OUT_STROKE_PRECIS - OUT_TT_PRECIS - OUT_DEVICE_PRECIS - OUT_RASTER_PRECIS - OUT_TT_ONLY_PRECIS - OUT_OUTLINE_PRECIS @param clip_precision: the precision of glyph clipping may have one of the following values: - CLIP_DEFAULT_PRECIS - CLIP_CHARACTER_PRECIS - CLIP_STROKE_PRECIS - CLIP_MASK - CLIP_LH_ANGLES - CLIP_TT_ALWAYS - CLIP_EMBEDDED @param quality: (subjective) quality of the font. Choose from the following values: - DEFAULT_QUALITY - DRAFT_QUALITY - PROOF_QUALITY - NONANTIALIASED_QUALITY - ANTIALIASED_QUALITY @param pitch_family: the pitch and family of the font face if the named font can't be found. Combine the pitch and style using a binary or. - Pitch: - DEFAULT_PITCH - FIXED_PITCH - VARIABLE_PITCH - MONO_FONT - Style: - FF_DONTCARE - FF_ROMAN - FF_SWISS - FF_MODERN - FF_SCRIPT - FF_DECORATIVE @param name: ASCII string containing the name of the font face. @return: handle of font. @rtype: int @type height: int @type width: int @type escapement: int @type orientation: int @type weight: int @type italic: int @type underline: int @type strike_out: int @type charset: int @type out_precision: int @type clip_precision: int @type quality: int @type pitch_family: int @type name: string (RRR(R/R!R RRRRRRRRRRRRt((s&code\common\utils\third_party\pyemf.pyt CreateFont< spcCs,tj|||}|j|s(dSdS(s5 Draw a string of text at the given position using the current FONT and other text attributes. @param x: x position of text. @param y: y position of text. @param text: ASCII text string to render. @return: true of string successfully drawn. @rtype: int @type x: int @type y: int @type text: string ii(RRR(R/RRttextR((s&code\common\utils\third_party\pyemf.pytTextOut sN(NR\R]R^RVR2RRRRRRRRRRRRRRRRRRRRRRRR RR RRRRRRRRRR R!R"R#R%R'R)R*R&R-R.R/R0R1R2R3R4R5R6R7R8R9R:R;R<RpR=R>R@RBRCRRRRRRDRF(((s&code\common\utils\third_party\pyemf.pyR s 1            $               )(        %  "     "       0rt__main__(t OptionParsertusages#usage: %prog [options] emf-files...s-vtactiont store_truetdestRzRqs-sRs-otstoret outputfileR|cBseZeZeZdZRS(N(R\R]R:RzRRRN(((s&code\common\utils\third_party\pyemf.pyR| ss.out.emfs Saving %s...s%s saved successfully.sproblem saving %s!snew.emf(R^t__extra_epydoc_fields__RtsystreRot cStringIORRRt __author__t__author_email__t__url__t__download_url__t__description__t __keywords__t __license__RAtBS_NULLt BS_HOLLOWt BS_HATCHEDt BS_PATTERNt BS_INDEXEDt BS_DIBPATTERNtBS_DIBPATTERNPTt BS_PATTERN8X8tBS_DIBPATTERN8X8tBS_MONOPATTERNRBt HS_VERTICALt HS_FDIAGONALt HS_BDIAGONALtHS_CROSSt HS_DIAGCROSStMM_TEXTt MM_LOMETRICt MM_HIMETRICt MM_LOENGLISHt MM_HIENGLISHtMM_TWIPSt MM_ISOTROPICRRt TRANSPARENTRRR tWINDINGR R;tPS_DASHtPS_DOTt PS_DASHDOTt PS_DASHDOTDOTtPS_NULLtPS_INSIDEFRAMEt PS_USERSTYLEt PS_ALTERNATEt PS_STYLE_MASKtPS_ENDCAP_ROUNDtPS_ENDCAP_SQUAREtPS_ENDCAP_FLATtPS_ENDCAP_MASKt PS_JOIN_ROUNDt PS_JOIN_BEVELt PS_JOIN_MITERt PS_JOIN_MASKt PS_COSMETICt PS_GEOMETRICt PS_TYPE_MASKt WHITE_BRUSHt LTGRAY_BRUSHt GRAY_BRUSHt DKGRAY_BRUSHt BLACK_BRUSHt NULL_BRUSHt HOLLOW_BRUSHt WHITE_PENt BLACK_PENtNULL_PENtOEM_FIXED_FONTtANSI_FIXED_FONTt ANSI_VAR_FONTt SYSTEM_FONTtDEVICE_DEFAULT_FONTtDEFAULT_PALETTEtSYSTEM_FIXED_FONTtDEFAULT_GUI_FONTRt TA_NOUPDATECPt TA_UPDATECPtTA_LEFTtTA_RIGHTt TA_CENTERtTA_TOPt TA_BOTTOMRt TA_RTLREADINGRt FW_DONTCAREtFW_THINt FW_EXTRALIGHTt FW_ULTRALIGHTtFW_LIGHTRt FW_REGULARt FW_MEDIUMt FW_SEMIBOLDt FW_DEMIBOLDtFW_BOLDt FW_EXTRABOLDt FW_ULTRABOLDtFW_HEAVYtFW_BLACKRtDEFAULT_CHARSETtSYMBOL_CHARSETtSHIFTJIS_CHARSETtHANGEUL_CHARSETtHANGUL_CHARSETtGB2312_CHARSETtCHINESEBIG5_CHARSETt GREEK_CHARSETtTURKISH_CHARSETtHEBREW_CHARSETtARABIC_CHARSETtBALTIC_CHARSETtRUSSIAN_CHARSETt EE_CHARSETtEASTEUROPE_CHARSETt THAI_CHARSETt JOHAB_CHARSETt MAC_CHARSETt OEM_CHARSETtVISCII_CHARSETt TCVN_CHARSETt KOI8_CHARSETt ISO3_CHARSETt ISO4_CHARSETt ISO10_CHARSETtCELTIC_CHARSETt FS_LATIN1t FS_LATIN2t FS_CYRILLICtFS_GREEKt FS_TURKISHt FS_HEBREWt FS_ARABICt FS_BALTICt FS_VIETNAMESEtFS_THAIt FS_JISJAPANtFS_CHINESESIMPt FS_WANSUNGtFS_CHINESETRADtFS_JOHABt FS_SYMBOLRtOUT_STRING_PRECIStOUT_CHARACTER_PRECIStOUT_STROKE_PRECISt OUT_TT_PRECIStOUT_DEVICE_PRECIStOUT_RASTER_PRECIStOUT_TT_ONLY_PRECIStOUT_OUTLINE_PRECISRtCLIP_CHARACTER_PRECIStCLIP_STROKE_PRECISt CLIP_MASKtCLIP_LH_ANGLEStCLIP_TT_ALWAYSt CLIP_EMBEDDEDRt DRAFT_QUALITYt PROOF_QUALITYtNONANTIALIASED_QUALITYtANTIALIASED_QUALITYRt FIXED_PITCHtVARIABLE_PITCHt MONO_FONTRtFF_ROMANtFF_SWISSt FF_MODERNt FF_SCRIPTt FF_DECORATIVERt GM_ADVANCEDtGM_LASTtAD_COUNTERCLOCKWISEt AD_CLOCKWISEt RGN_ERRORtRGN_ANDtRGN_ORtRGN_XORtRGN_DIFFRpRnRoRtICM_ONt ICM_QUERYRRR1tMWT_LEFTMULTIPLYtMWT_RIGHTMULTIPLYRR RRR_tobjectRuRRtdirRttgetattrRRtcallablet issubclassRkRR\toptparseRHtparsert add_optionRVt parse_argstoptionstargsR|targvRORRzRRRRNR(((s&code\common\utils\third_party\pyemf.pyts $     ) !