h  RdZddlmZddlmZmZmZmZmZm Z m Z m Z ddl Z ddl Z ddlZddlmZmZddlmZmZmZmZmZmZddlmZmZmZmZmZmZm Z ddl!m"Z"m#Z#m$Z$dd l%m&Z&m'Z'm(Z(erdd l)m*Z*m+Z+m,Z,dd l-m.Z.dd l/m0Z0d Z1GddZ2dGdZ3dHdZ4dIdZ5dJdZ6dZ7dKdLdZ8dJdZ9dMdNdZ: dO dPdZ;dJdZ dTdZ?dUdZ@ejdej4dej8d ej6d!ejd"ejd#iZDd$ZEd%ZFdVd&ZGGd'd(e ZHGd)d*ZIGd+d,eJZKGd-d.ZLGd/d0ZMGd1d2e jZOGd3d4ZPe jd5ZRe jd6ZSej4ej8ej6ejejd7ZTGd8d9ZUdWd:ZVdXd;ZWdYdZd<ZXdYd[d=ZYd\d]d>ZZd^d?Z[d@a\d_dAZ]d`dBZ^ da dbdCZ_e fdcdDZ`eadEZbdddFZcy)ezL Tools in this module should be as independent of DXF entities as possible! ) annotations)IterableIterator TYPE_CHECKINGUnionOptionalCallable NamedTupleAnyN) validatorconst)TextEntityAlignment TextHAlignMTextParagraphAlignmentMTextLineAlignment MTextStrokeMAP_MTEXT_ALIGN_TO_FLAGS)LEFTCENTERRIGHTBASELINEMIDDLETOP MAX_STR_LEN)Vec3Vec2UVec)rgb2intRGBint2rgb)TextMText DXFEntity)TagsfontsceZdZdZddZddZeddZeddZddZ d dd Z d dd Z dd Z e edddd dddf dd Zy)TextLineaHelper class which represents a single line text entity (e.g. :class:`~ezdxf.entities.Text`). Args: text: content string font: ezdxf font definition like :class:`~ezdxf.fonts.fonts.MonospaceFont` or :class:`~ezdxf.fonts.fonts.TrueTypeFont` cZ||_|j||_d|_d|_y)N?)_font text_width _text_width _stretch_x _stretch_y)selftextfonts 0lib/python3.12/site-packages/ezdxf/tools/text.py__init__zTextLine.__init__?s( "&//$"7!$!$ct|tsJd}d}|tjtjfvrB||z j}|j dkDr$||j z }|tjk(r|}||_||_y)zSet stretch factors for FIT and ALIGNED alignments to fit the text between `p1` and `p2`, only the distance between these points is important. Other given `alignment` values are ignore. r+g& .>N) isinstancerFITALIGNED magnituder.r/r0)r1 alignmentp1p2sxsydefined_lengths r4stretchzTextLine.stretchEs )%8999 ,002E2M2MN N%'"W$7$7N$&#d&6&66 3 ; ;;Br6c4|j|jzS)z)Returns the final (stretched) text width.)r.r/r1s r4widthzTextLine.widthWs$//11r6c\|jjj|jzS)z*Returns the final (stretched) text height.)r, measurements total_heightr0rDs r4heightzTextLine.height\s#zz&&33dooEEr6c`|jjj|jS)z%Returns the scaled font measurements.)r,rGscaler0rDs r4font_measurementszTextLine.font_measurementsas!zz&&,,T__==r6rrNc|j}td|jt|j|jg}|j |||}t j |||||S)azReturns the left and the right baseline vertex of the text line. Args: insert: insertion location halign: horizontal alignment left=0, center=1, right=2 valign: vertical alignment baseline=0, bottom=1, middle=2, top=3 angle: text rotation in radians scale: scale in x- and y-axis as 2-tuple of float r)rLrbaselinerE _shift_vectorr) transform_2d) r1inserthalignvalignanglerKfmverticesshifts r4baseline_verticeszTextLine.baseline_verticesesj$ # # % BKK R[[ ) ""6626$$XvueUKKr6cP|j}td|jt|j|jt|j|jtd|jg}|j |||} t j||| |||S)aReturns the corner vertices of the text line in the order bottom left, bottom right, top right, top left. Args: insert: insertion location halign: horizontal alignment left=0, center=1, right=2 valign: vertical alignment baseline=0, bottom=1, middle=2, top=3 angle: text rotation in radians scale: scale in x- and y-axis as 2-tuple of float oblique: shear angle (slanting) in x-direction in radians r)rLrbottomrEcap_toprQr)rR) r1rSrTrUrVrKobliquerWrXrYs r4corner_verticeszTextLine.corner_verticess* # # % BII  RYY ' RZZ ( BJJ    ""6626$$XvueUGTTr6cFt|j|t||fSN)_shift_xrE_shift_y)r1rTrUrWs r4rQzTextLine._shift_vectors! F+Xb&-AAAr6)rrc@ tj|}|r tj| fd|D}t| r fd|D}|\ dk7s dk7r  fd|D}r fd|D}t |}|Dcgc]}||z c}Scc}w)aTransform any vertices from the text line located at the base location at (0, 0) and alignment LEFT. Args: vertices: iterable of vertices insert: insertion location shift: (shift-x, shift-y) as 2-tuple of float rotation: text rotation in radians scale: (scale-x, scale-y) as 2-tuple of float oblique: shear angle (slanting) in x-direction in radians c3~K|]4}t|j|jzz|j6ywrarxy).0vslant_xs r4 z(TextLine.transform_2d..s.KAaccACC'M11337s:=c3(K|] }|z ywra)rirj shift_vectors r4rlz(TextLine.transform_2d..s=9a\)9srNc3jK|]*}t|jz|jz,ywrarf)rirjscale_xscale_ys r4rlz(TextLine.transform_2d..s)OYaccGmQSS7];Ys03c3@K|]}|jywra)rotate)rirjrotations r4rlz(TextLine.transform_2d..s?Y(+Ys)rgeneratemathtanr) rXrSrYrurKr^ vertices_rjrqrrrorks ` @@@@r4rRzTextLine.transform_2dsD%)MM($;  hhw'GKKIE{ =9=I! a<7a<OYOI ?Y?If$-.Iq I...s BN)r2strr3fonts.AbstractFont)r<rr=rr>rreturnNoner|float)r|fonts.FontMeasurements)rrrrM) rSrrTintrUrrVrrKtuple[float, float]r| list[Vec3])rrrrMr)rSrrTrrUrrVrrKrr^rr|r)rTrrUrrWrr|r)rXzIterable[UVec]rSrrYrrurrKrr^rr|r)__name__ __module__ __qualname____doc__r5rBpropertyrErIrLrZr_rQ staticmethodrrRrnr6r4r)r)4s% $22FF>%+ LLL L  L # L L>%+UUU U  U # UU U>BB#&B,BB B Aq!}%+%+ 8/ 8/8/#8/ 8/ # 8/  8/ 8/8/r6r)c:|tk(r| dz S|tk(r| Sy)Ng@)rr) total_widthrTs r4rbrbs) |c!! | r6c |tk(r |jS|tk(r|j |jdz zS|t k(r|j |j dz zS|tk(r |j S|j S)N) rrPrr] cap_heightX_MIDDLErHrr\)rWrUs r4rcrcsw {{  {R]]Q...  {R__q000 } { II:r6c|j}|dvr|jj}|jj}|tj tj fvrt}t}||fS|tjk(r t}t}||fS|dk(r4tj|jjttfSt!d|)zReturn unified horizontal and vertical alignment. horizontal alignment: left=0, center=1, right=2 vertical alignment: baseline=0, bottom=1, middle=2, top=3 Returns: tuple(halign, valign) )TEXTATTRIBATTDEFMTEXTz invalid DXF )dxftypedxfrTrUrr:r9rrrrrgetattachment_pointrr TypeError)entityrrTrUs r4unified_alignmentrsnnG.."""" j((*..9 9FFv~z(( (FFv~''++FJJ,G,G$PSUU l7), --r6cd}ttjt|}|jr|j }|dk(r|j ddk(rm|j dj }tjj|}|r|jd||z }|dvr|jd|jd||z }|jr|S)zReturns the plain text for :class:`~ezdxf.entities.Text`, :class:`~ezdxf.entities.Attrib` and :class:`~ezdxf.entities.Attdef` content. %rNrkou) TextScannerr fix_one_line_text caret_decodehas_datapeeklowerr SPECIAL_CHAR_ENCODINGrconsume)r2resultscannercharcodeletters r4 plain_textrsF)55l46HIJG   ||~ 3;||A#%||A,,.4488>OOA&f$F5=OOA&$#   $ Mr6 PNLlOoKkXcg}ttt|}|rv|j}|dk(r |j}|dvr|j |n5|t vr0|dk(r|j dn|dk(r|j dn|dk(}|}|j} |dk7r.|j}|r|dk7r|j ||dk7r.|}n|d vrn|d k(r|r|d d k(rx|j|r|j}tjj|j} | r|j | n8|jd d |fn#|j |n|j ||rvd j|} |r| jdS| S#t$rY1wxYw#t$r%|j d|j |YfwxYw) aReturns the plain MTEXT content as a single string or a list of strings if `split` is ``True``. Replaces ``\P`` by ``\n`` and removes other controls chars and inline codes. This function is more than 4x faster than :func:`plain_mtext`, but does not remove single letter inline commands with arguments without a terminating semicolon like this ``"\C1red text"``. .. note:: Well behaved CAD applications and libraries always create inline codes for commands with arguments with a terminating semicolon like this ``"\C1;red text"``! Args: text: MTEXT content string split: split content at line endings ``\P`` \\{}P N S;z{}rr)listreversedrpop IndexErrorappendONE_CHAR_COMMANDScopyr rrrextendjoinsplit) r2rchars raw_charsrstacking first_char search_charsrrrs r4fast_plain_mtextrs( EXl4012I }} 4<  }}v~ T"**3;LL&S[LL% 3;! (~~/  -#++//1# !LL. #+ !-I T\  S[Yr]c1 $==?D"88<.replace_matchs'  A AFc>""r6z\^(.))rzre.Matchr|rz)resub)r2rs r4rrs# 66(M4 00r6cg}d} ||||z}t|rJt||kr|j||S||z }|ddk(r |dd}|dz}|j|n|S`)z9Split the MTEXT content string into chunks of max `size`.rr^NrN)lenr)ssizechunksposchunks r4split_mtext_stringrs F C #d # u:5zD  e$ 4KCRyCcr q MM% M r6c bg}g}tt^}}}}} } } } }d|z} t|D]}|j}||k(r|j |j 0||k(s|| k(r|j dL|| k(s|| k(r1|j dj ||j|| k(r|j | ||k(s|j \}}}|j ||z|z|r |j dj ||r|Sdj |S)aReturns the plain MTEXT content as a single string or a list of strings if `split` is ``True``. Replaces ``\P`` by ``\n`` and removes other controls chars and inline codes. This function is much slower than :func:`fast_plain_mtext`, but removes all inline codes. Args: text: MTEXT content string split: split content at line endings ``\P`` tabsize: count of replacement spaces for tabulators ``^I`` rrr)iter TokenType MTextParsertyperdatarclear)r2rtabsizecontent paragraph_wordstackspacenbsp tabulator new_paragraph new_columntab_replacementtokentuprlwrdividers r4 plain_mtextrs/$GI Y       GmOT" JJ 9   UZZ ( %Z19   S ! - 1 ? NN2779- . OO  )^   _ - %Z % Cg   S7]S0 1#rwwy)*  99W r6cF|jddjddS)N rr\Preplacer2s r4escape_dxf_line_endingsrNs" <<b ! ) )$ 66r6c8djfd|DS)Nrc3<K|]}t|rn|ywra)is_non_printable_char)rir replacements r4rlz3replace_non_printable_characters..UsP4a"7":;A4s)r)r2rs `r4 replace_non_printable_charactersrTs 77P4P PPr6cBdt|cxkxrdkncxr|dk7S)Nr  )r)rs r4rrXs D B  /44</r6c`|r|jrgStjd|}|Dcgc]"}tjd|D]}|s| $}}}g}d}d} |D]}| } |dk(r| rd} |dk(r"|j|j d}7|jr |s| sL||z }R|:|||z|kDr,|s||z }j|j|j |}d} ||z }|r/|js|j|j |Scc}}w)aWrap text at ``\n`` and given `box_width`. This tool was developed for usage with the MTEXT entity. This isn't the most straightforward word wrapping algorithm, but it aims to match the behavior of AutoCAD. Args: text: text to wrap, included ``\n`` are handled as manual line breaks box_width: wrapping length, ``None`` to just wrap at ``\n`` get_text_width: callable which returns the width of the given string z(\n)z(\s+)rFrT)isspacerrrrstrip) r2 box_widthget_text_width manual_lineslinertokenslines current_lineline_just_wrapped on_first_lines r4 text_wrapr\s9" 4<<> 88GT*L( PLD"((8T2JQaa2JaLF PEL ! 9* ! 9 LL,,. /L YY[}! $ q8H)II)U# A%LLL!4!4!67#$L(,%! ),L002 \((*+ L;Qs D*D*c|jdst|jd|jrG|jjj |j j}|r |jSy)zhReturns ``True`` if the associated text :class:`~ezdxf.entities.Textstyle` is vertical stacked. stylez& does not support the style attribute.F) is_supported_dxf_attribrrdocstylesrrris_vertical_stacked)r2rs r4is_text_vertical_stackedrse  ' ' 04<<>**PQRR xx##DHHNN3 ,, , r6rlrrjd, 01234567890c:t|ttfr|dS|S)Ng)r8rr)rs r4rstrip0r$s!c5\"A Hr6c~eZdZUdZdZded<dZded<dZded<ejZ ded<e Z d ed <d d Z y )ParagraphPropertiesa<Stores all known MTEXT paragraph properties in a :class:`NamedTuple`. Indentations and tab stops are multiples of the default text height :attr:`MText.dxf.char_height`. E.g. :attr:`char_height` is 0.25 and :attr:`indent` is 4, the real indentation is 4 x 0.25 = 1 drawing unit. The default tabulator stops are 4, 8, 12, ... if no tabulator stops are explicit defined. Args: indent (float): left indentation of the first line, relative to :attr:`left`, which means an :attr:`indent` of 0 has always the same indentation as :attr:`left` left (float): left indentation of the paragraph except for the first line right (float): left indentation of the paragraph align: :class:`~ezdxf.lldxf.const.MTextParagraphAlignment` enum tab_stops: tuple of tabulator stops, as ``float`` or as ``str``, ``float`` values are left aligned tab stops, strings with prefix ``"c"`` are center aligned tab stops and strings with prefix ``"r"`` are right aligned tab stops rrindentleftrightraligntuple tab_stopsc >g}|jr4|jd|jd|jt|jr4|jd|jd|jt|jr4|jd|jd|jt|j r:|jdt |j |jt|jrT|jdtjtt|j|jt|r3|dtk(r|jdd j|zd zSy ) zdReturns the MTEXT paragraph properties as MTEXT inline code e.g. ``"\pxi-2,l2;"``. ir#rrqrrz\pxrr) r'rCOMMAr(r)r*_alignment_charr,rmapr$r)r1argss r4tostringzParagraphProperties.tostrings+  ;; KK!DKK?+ , KK  99 KK!DIIa=) * KK  :: KK!DJJq>* + KK  :: KK!ODJJ789 : KK  >> KK!EJJs7DNN'CDEF G KK  Bx5  BGGDM)C/ /r6Nr|rz)rrrrr'__annotations__r(r)rDEFAULTr*r+r,r4rnr6r4r&r&sJ,FED%OE5%<%D%DE "D wIur6r&c eZdZdZd'd(dZdZdZdZdZdZ dZ dZ d Z d Z d Zd Zd ZdZdZdZdZd)dZd)dZd*dZdZd+d,dZd-dZd.dZd-dZd-dZd/dZd0dZd1dZ d2dZ!d3d4dZ"d)d Z#d)d!Z$d)d"Z%d)d#Z&d5d$Z' d6d%Z(y&)7 MTextEditora The :class:`MTextEditor` is a helper class to build MTEXT content strings with support for inline codes to change color, font or paragraph properties. The result is always accessible by the :attr:`text` attribute or the magic :func:`__str__` function as :code:`str(MTextEditor("text"))`. All text building methods return `self` to implement a floating interface:: e = MTextEditor("This example ").color("red").append("switches color to red.") mtext = msp.add_mtext(str(e)) The initial text height, color, text style and so on is determined by the DXF attributes of the :class:`~ezdxf.entities.MText` entity. .. warning:: The :class:`MTextEditor` assembles just the inline code, which has to be parsed and rendered by the target CAD application, `ezdxf` has no influence to that result. Keep inline formatting as simple as possible, don't test the limits of its capabilities, this will not work across different CAD applications and keep the formatting in a logic manner like, do not change paragraph properties in the middle of a paragraph. **There is no official documentation for the inline codes!** Args: text: init value of the MTEXT content string. c$t||_yra)rzr2r1r2s r4r5zMTextEditor.__init__s I r6rz\N\L\l\O\o\K\k{}z\A0;z\A1;z\A2;\~z^Ic0|xj|z c_|S)zAppend `text`.rr;s r4rzMTextEditor.append*s T  r6c0|xj|z c_|S)z} Append `text`:: e = MTextEditor("First paragraph.\P") e += "Second paragraph.\P") rr;s r4__iadd__zMTextEditor.__iadd__/s T  r6c|jS)z1Returns the MTEXT content attribute :attr:`text`.rrDs r4__str__zMTextEditor.__str__: yyr6cd|_y)z%Reset the content to an empty string.rNrrDs r4rzMTextEditor.clear>s  r6c \|jd|dt|dt|dS)aSet the text font by the font family name. Changing the font height should be done by the :meth:`height` or the :meth:`scale_height` method. The font family name is the name shown in font selection widgets in desktop applications: "Arial", "Times New Roman", "Comic Sans MS". Switching the codepage is not supported. Args: name: font family name bold: flag italic: flag z\fz|bz|irrr)r1namebolditalics r4r3zMTextEditor.fontBs0&{{bbT 2c&k]!DEEr6c@|jdt|ddS)aScale the text height by a `factor`. This scaling will accumulate, which means starting at height 2.5 and scaling by 2 and again by 3 will set the text height to 2.5 x 2 x 3 = 15. The current text height is not stored in the :class:`MTextEditor`, you have to track the text height by yourself! The initial text height is stored in the :class:`~ezdxf.entities.MText` entity as DXF attribute :class:`~ezdxf.entities.MText.dxf.char_height`. \Hrzx;rroundr1factors r4 scale_heightzMTextEditor.scale_heightWs${{bvq!1 2"566r6c@|jdt|ddS)z.Set the absolute text height in drawing units.rRrrrS)r1rIs r4rIzMTextEditor.heightc"{{bvq!1 2!455r6c@|jdt|ddS)z#Set the absolute text width factor.z\WrrrSrUs r4 width_factorzMTextEditor.width_factorgrYr6c@|jdt|ddS)z+Set the absolute character tracking factor.z\TrrrSrUs r4char_tracking_factorz MTextEditor.char_tracking_factorkrYr6c>|jdt|dS)zSet the text oblique angle in degrees, vertical is 0, a value of 15 will lean the text 15 degree to the right. z\QrrM)r1rVs r4r^zMTextEditor.obliqueos {{bU A.//r6cb|jtj|jS)zsSet the text color by color name: "red", "yellow", "green", "cyan", "blue", "magenta" or "white". )acir MTEXT_COLOR_INDEXr)r1rNs r4colorzMTextEditor.colorvs$ xx// =>>r6crd|cxkrdkr"n td|jd|dStd)z3Set the text color by :ref:`ACI` in range [0, 256].rz\Crzaci not in range [0, 256])r ValueErrorr1r`s r4r`zMTextEditor.aci}s> ?s?455;;"SE|, ,455r6cP|\}}}|jdt|||fdS)z Set the text color as RGB value.z\cr)rr)r1rgbrr#bs r4rhzMTextEditor.rgbs11a{{b!Q!3 4A677r6cl|dvrtd||dk(r|dz }|jd|||dS)a"Append stacked text `upr` over `lwr`, argument `t` defines the kind of stacking, the space " " after the "^" will be added automatically to avoid caret decoding: .. code-block:: none "^": vertical stacked without divider line, e.g. \SA^ B: A B "/": vertical stacked with divider line, e.g. \SX/Y: X - Y "#": diagonal stacked, with slanting divider line, e.g. \S1#4: 1/4 ^/#zinvalid type symbol: rrz\Sr)rer)r1rrrs r4rzMTextEditor.stacksN( E>4QC89 9 8 HA{{baSQ/00r6c,|jd|dS)zGroup `text`, all properties changed inside a group are reverted at the end of the group. AutoCAD supports grouping up to 8 levels. rBrCrr;s r4rzMTextEditor.groups {{RvR=))r6c,|jd|dS)z)Append `text` with a line below the text.r<r=rmr;s r4 underlinezMTextEditor.underline{{bb>**r6c,|jd|dS)z)Append `text` with a line above the text.r>r?rmr;s r4overlinezMTextEditor.overlinerpr6c,|jd|dS)z+Append `text` with a line through the text.r@rArmr;s r4strike_throughzMTextEditor.strike_throughrpr6c@|j|jS)zBSet paragraph properties by a :class:`ParagraphProperties` object.)rr4)r1propss r4rzMTextEditor.paragraphs{{5>>+,,r6c tjt| dz||f}|jdj fdt ||Dj t|S)u/Build bulleted lists by utilizing paragraph indentation and a tabulator stop. Any string can be used as bullet. Indentation is a multiple of the initial MTEXT char height (see also docs about :class:`ParagraphProperties`), which means indentation in drawing units is :attr:`MText.dxf.char_height` x `indent`. Useful UTF bullets: - "bull" U+2022 = • (Alt Numpad 7) - "circle" U+25CB = ○ (Alt Numpad 9) For numbered lists just use numbers as bullets:: MTextEditor.bullet_list( indent=2, bullets=["1.", "2."], content=["first", "second"], ) Args: indent: content indentation as multiple of the initial MTEXT char height bullets: iterable of bullet strings, e.g. :code:`["-"] * 3`, for 3 dashes as bullet strings content: iterable of list item strings, one string per list item, list items should not contain new line or new paragraph commands. g?)r'r(r,rc3bK|]&\}}|jz|zjz(ywra)TAB NEW_PARAGRAPH)ririrr1s r4rlz*MTextEditor.bullet_list..s2BW$!QDHH q 4#5#55BWs,/)r9rr&rrziprrz)r1r'bulletsritemss` r4 bullet_listzMTextEditor.bullet_listss< '' w~!)    GGBEgwBW  zz#e*%%r6N)rr2rz)r2rzr|r9r5)FF)rNrzrOboolrPrr|r9)rVrr|r9)rIrr|r9)rVrr|r9)rNrzr|r9)r`rr|r9)rhrr|r9)r)rrzrrzrrzr|r9)rvr&r|r9)r'rr| Iterable[str]rrr|r9))rrrrr5NEW_LINErz NEW_COLUMNUNDERLINE_STARTUNDERLINE_STOPOVERSTRIKE_STARTOVERSTRIKE_STOP STRIKE_START STRIKE_STOP GROUP_START GROUP_END ALIGN_BOTTOM ALIGN_MIDDLE ALIGN_TOPNBSPryrrGrIrr3rWrIr[r]r^rbr`rhrrrorrrtrr~rnr6r4r9r9s@HMJONOLKKILLI D C F* 76660?6 8 16*+++-*&*&&3*&>K*& *&r6r9c eZdZy)UnknownCommandN)rrrrnr6r4rrsr6rc.eZdZdZddZddZeZdZddZe ddZ e jddZ dddZ e dd Z e jdd Z e dd Zejdd Ze dd ZejddZe ddZy) MTextContextz0Internal class to store the MTEXT context state.cddlm}d|_d|_d|_d|_t j|_|j|_ d|_ d|_ d|_ d|_t|_y)Nrr%Fr+r) ezdxf.fontsr&_strokecontinue_stroke_acirhrBOTTOMr*FontFace font_facerr[r]r^r&r)r1r&s r4r5zMTextContext.__init__sg% %* "&'.. ')!$#&+.!! ,.r6ct}|j|_|j|_|j|_|j|_|j |_|j |_|j|_|j|_|j|_ |j|_ |j|_ |Sra) rrrrrhr*rrr[r]r^r)r1ps r4__copy__zMTextContext.__copy__s NLL  00**nn  **!%!:!:LL nn r6c  t|j|j|j|j|j |j |j|j|j|j|jf Sra) hashrrrrhr*rrr[r]r^rrDs r4__hash__zMTextContext.__hash__sg $$  !!))    r6c0t|t|k(Sra)r)r1others r4__eq__zMTextContext.__eq__sDzT%[((r6c|jSra)rrDs r4r`zMTextContext.aci"rJr6cfd|cxkrdkrn td||_d|_ytd)Nrrdzaci not in range[0,256])rrhrerfs r4r`zMTextContext.aci&s7 ?s?67 7DIDH67 7r6c`|r|xj|zc_y|xj|zc_y)zSet/clear binary `stroke` flag in `self._stroke`. Args: stroke: set/clear stroke flag state: ``True`` for setting, ``False`` for clearing N)r)r1strokestates r4_set_stroke_statezMTextContext._set_stroke_state.s%  LLF "L LLVG #Lr6cNt|jtjzSra)rrr UNDERLINErDs r4rozMTextContext.underline;sDLL;#8#8899r6cD|jtj|yra)rrrr1values r4rozMTextContext.underline?s {44e>r6cD|jtj|yra)rrrrs r4rtzMTextContext.strike_throughGs {995Ar6cNt|jtjzSra)rrrOVERLINErDs r4rrzMTextContext.overlineKsDLL;#7#7788r6cD|jtj|yra)rrrrs r4rrzMTextContext.overlineOs {33U;r6c,t|jSra)rrrDs r4has_any_strokezMTextContext.has_any_strokeSsDLL!!r6Nr|r})r|rr|rr|r)r`r)T)rrrrr|r})rrr|r})rrrrr5rrrrrr`setterrrortrrrrnr6r4rrs: /  D ") ZZ88 $::==??BB99__<<""r6rceZdZdZddZeddZeddZddZdddZ dddZ dddZ ddd Z ddd Z dd Zdd Zdd ZddZy)r)_text _text_len_indexcft||_t|j|_d|_y)Nr)rzrrrrr;s r4r5zTextScanner.__init__[s#Y TZZ r6c4|j|jk\SrarrrDs r4is_emptyzTextScanner.is_empty`s{{dnn,,r6c4|j|jkSrarrDs r4rzTextScanner.has_datads{{T^^++r6c |j|j}|xjdz c_|S#t$rYywxYw)NrNrrrr)r1rs r4rzTextScanner.gethsB ::dkk*D KK1 K   s .2 >>cN|dkr t||xj|z c_y)NrN)rerr1counts r4rzTextScanner.consumeps" 19U# # u r6c.|xj|z c_y)zconsume() without safety checkNrrs r4 fast_consumezTextScanner.fast_consumeus u r6cz|dkr t| |j|j|zS#t$rYywxYw)Nrr)rerrrr1offsets r4rzTextScanner.peekysC A:V$ $ ::dkkF23 3  s . ::cZ |j|j|zS#t$rYywxYw)zpeek() without safety checkrrrs r4 fast_peekzTextScanner.fast_peeks1 ::dkkF23 3  s  **c^|j|j|jd}|jry|j }|r+|dk(r&|j d|k(r|j dI||k(r|j|jzS|j d|jryy)atReturn the index of the next `char`. If `escape` is True, backslash escaped `chars` will be ignored e.g. "\;;" index of the next ";" is 1 if `escape` is False and 2 if `escape` is True. Returns -1 if `char` was not found. Args: char: single letter as string escape: ignore backslash escaped chars if True. NrrNrr) __class__rrrrr)r1rescaperrs r4findzTextScanner.finds..DKKM!:; A!t) Q4(?"Dy{{W^^33 OOA r6ch||jkr t||j|j|S)zCReturns the substring from the current location until index < stop.)rrr)r1stops r4substrzTextScanner.substrs. $++ T" "zz$++--r6c4|j|jdS)z,Returns the unprocessed part of the content.N)rrrDs r4tailzTextScanner.tailszz$++-((r6c|jSrarrDs r4indexzTextScanner.indexs {{r6c |j||Sra)r)r1startrs r4substr2zTextScanner.substr2szz%%%r6Nrrr5)rN)rrr|r})r)rrr|rzF)rrzr|r)rrr|rzr)rrrrr|rz)rrr __slots__r5rrrrrrrrrrrrrrnr6r4rrXsf0I --,, .. )&r6rc4eZdZdZdZdZdZdZdZdZ dZ d Z d Z y ) rrrNrrr'r N) rrrNONEWORDSTACKSPACEr TABULATORrzrWRAP_AT_DIMLINEPROPERTIES_CHANGEDrnr6r4rrs5 D D E E DIMJOr6rceZdZdZdddZy) MTextTokenrctxrNc.||_||_||_yrar)r1rrrs r4r5zMTextToken.__init__s  !$ r6ra)rrrr)rrrrr5rnr6r4rrs 'Ir6rz#[+-]?\d+(:?\.\d*)?(:?[eE][+-]?\d+)?z)[+-]?\d+(:?\.\d*)?(:?[eE][+-]?\d+)?([x]?))rrrrrceZdZdZ d ddZddZddZddZddZddZ dd Z dd Z dd Z dd Z dd ZddZddZddZddZd d!dZd!dZd d!dZddZddZdZy)"raParses the MText content string and yields the content as tokens and the current MText properties as MTextContext object. The context object is treated internally as immutable object and should be treated by the client the same way. The parser works as iterator and yields MTextToken objects. Args: content: MText content string ctx: initial MText context yield_property_commands: yield commands that change properties or context, default is ``False`` Nc| t}||_tt||_g|_d|_t||_yNF) rrrrr _ctx_stack_continue_stroker_yield_property_commands)r1rryield_property_commandss r4r5zMTextParser.__init__sE ;.C"<#89 .0 %(,-D(E%r6c"|jSra)parserDs r4__iter__zMTextParser.__iter__szz|r6cN|jj|jyra)rrrrDs r4push_ctxzMTextParser.push_ctxs txx(r6c\|jr |jj|_yyra)rrrrDs r4pop_ctxzMTextParser.pop_ctxs" ??**,DH r6c#X Kjjjdtjtj  fd d fd } |\}}|r7t |j|rt jddnyEw)Nc*|r||fS|dfSrarn)rrrfollowup_token word_tokens r4word_and_tokenz)MTextParser.parse..word_and_tokens% I!&!4''$; r6cd} jr#d}} j}|dk(rddvrd}}n|r |fS j}|dk(rtjdfS|dk(rtj dfS|d k(rtj dfS|d k(rtjdfS|d k(r jS|rN j| jr0tj j| jfS&|d kr;|d k(r |tjS|dk(r |tj Sd }nQ|dk(rLddk(rAdj}t j"j|}|r d|}|d k(r  | S|sJ|dk(r |r |fSd j%|dk(r |r |fSd j'|d k\r||z } jr#|r |fStj(dfS#t$r |||zz }Y8wxYw)NrFrrNrT~rrXrrrrrrrBrC)rrrrrrzrrparse_stackingparse_propertiesrrrrrrr rrrr)rrrcmd_start_indexcmdr special_charrrrr1 space_tokenrrs r4 next_tokenz%MTextParser.parse..next_token sD""")--/T>Aw&(!% !% #-t#33 %kkm#:#,>>4#77#:#,#:#:D#@@#:#,#7#7#==#:#,#<##>#B#B4#HL# !-S=)$ <<}#-t#33#AJ MMO$3#-t#33#AJ LLN$ S=FNDa""d!4'' ~~t++o$25 $ 45sI I! I!r|ztuple[TokenType, Any])rrrrrrrr) r1rtype_rrrrrrrrs ` @@@@@@@r4rzMTextParser.parses,,&&  .2oo ^^  X ,X ,t$,KE4 $77!$^TXXtDD%)NsB B*cfdfddfd }d fd }t|jd|\}}|r|nd}tj|||ffS) aReturns a tuple of strings: (numerator, denominator, type). The numerator and denominator is always a single and can contain spaces, which are not decoded as separate tokens. The type string is "^" for a limit style fraction without a line, "/" for a horizontal fraction and "#" for a diagonal fraction. If the expression does not contain any stacking type char, the type and denominator string are empty "". cHj}t|dkrd}|S)Nrr)rr)rstacking_scanners r4 peek_charz-MTextParser.parse_stacking..peek_charzs& %%'A1v{Hr6c~d}}|dk(rd}jd}jd||fS)NFrTrN)r)rrrrs r4 get_next_charz1MTextParser.parse_stacking..get_next_charsHF ADy ((+K  $ $Q 'f9 r6ctd}jr&\}}|s|dvr||fS||z }jr&|dfS)Nrrkr)rrrrrs r4parse_numeratorz3MTextParser.parse_stacking..parse_numeratorsMD"++)O 6!u*7N  #++ 8Or6cXd}jr|dz }jr|S)Nrrr)rrrs r4parse_denominatorz5MTextParser.parse_stacking..parse_denominators2D"++ **#++Kr6Trr)r|ztuple[str, str]r5)rextract_expressionrr) r1rr numerator stacking_type denominatorrrrs @@@r4r zMTextParser.parse_stackingpsb     't'>'>d'>'KL#2#4 =-:') K GGGr6cr|jj}|dk(rd|_d|_np|dk(rd|_|jsWd|_nN|dk(rd|_d|_n9|dk(rd|_|js d|_n|dk(rd|_d|_n|dk(rd|_|jsd|_n|d k(r|j|n|d k(r|j|n|d k(r|j|n|d k(r|j|n|d k(r|j|no|dk(r|j|nX|dk(r|j|nA|dk(r|j|n*|dk(s|dk(r|j|nt!d||j|_||_y)NLTrFOoKkACrHWQTrfFzunknown command: )rrrorrrrrt parse_alignparse_aci_colorparse_rgb_color parse_height parse_width parse_obliqueparse_char_trackingparse_paragraph_propertiesparse_font_propertiesrr)r1r new_ctxs r4r zMTextParser.parse_propertiess((--/ #: $G $(D ! CZ %G ))(-% CZ#G $(D ! CZ$G ))(-% CZ%)G "$(D ! CZ%*G "))(-% CZ   W % CZ   ) CZ   ) CZ   g & CZ   W % CZ   w ' CZ  $ $W - CZ  + +G 4 CZ3#:  & &w / #4SE!:; ;"&"7"7r6c|jj}|dvrtt||_ntj |_|j y)N012)rrrrr*rconsume_optional_terminator)r1rrs r4r1zMTextParser.parse_alignsD||! 5=*3t95CI*11CI ((*r6cd|j|j|_|jyra)parse_float_value_or_factorrr=r1rs r4r4zMTextParser.parse_heights$99#..I ((*r6cd|j|j|_|jyra)r?r[r=r@s r4r5zMTextParser.parse_widths';;C.parse_float+s!E#%Dd Lr6cd}j}tjt|}|r0|j \}}|||}j ||SrR)rrrrTrUr)rIrrrrWparagraph_scanner skip_commass r4r\z@MTextParser.parse_paragraph_properties..parse_float_expr2s[D$))+DHHXt,E"ZZ\ sE#!))#. Kr6cxjdk(r&jdjdk(r%yy)Nr rN)rr)r_sr4r`z;MTextParser.parse_paragraph_properties..skip_commas=s5#((*c1!))!,$((*c1r6r.rrrgr/rrr~r5)rrrrr CHAR_TO_ALIGNrr7rrrrr&r+)r1rr]r'r(r)r*r,r  adjustmentr float_exprr_r\r`s @@@r4r8z&MTextParser.parse_paragraph_properties*sm   -((?(?(AB03 -eUI((#'')Ccz$"}# .224 %))*6M6U6UV  '00-224E|u|)113!((1A1C)CD%5%7 %%,,U:->?.557(00! ((:, D%i(8  r6c ddlm}|jjd}|r\|drV|d}d}d}|ddD]*}|j drd}|j d s)d },|j ||| |_yyy) Nrr%|RegularirNb1ii1Italic)familyrweight)rr&rr startswithrr)r1rr&partsrNrrlparts r4r9z!MTextParser.parse_font_propertiesds%'')//4 U1X8DEFab ??4( F__T*$E " +ENN$eFSCM5r6cv|jjdk(r|jjdyy)NrrN)rrrrDs r4r=z'MTextParser.consume_optional_terminatorvs. <<   # % LL  # &r6r)rrzrzOptional[MTextContext])r|zIterator[MTextToken]rr)r rzr|r})rrr~rr5)rrrrr5rrrrr r r1r4r5r7r?r6r2r3rFrMrr8r9r=rnr6r4rrs $'+ % F F$ F)-tl-H^.`++++ + ++  8 tT$$r6rc`d}d}|D]\}}|dk(r|}|dk(s||z }t||zS)NrrNr)r)tagsrrrrs r4load_mtext_contentrs{sH DG e 19D QY u G  #7T> 22r6cJd|jddjddvS)zDReturns `True` if `text` contains any MTEXT inline formatting codes.rrrrDrrs r4has_inline_formatting_codesrus0 4<< r g r r6c8|dz}d|z|cxkxrd|z kScS)uReturns ``True`` if the given text `angle` in degrees causes an upside down text in the :ref:`WCS`. The strict flip range is 90° < `angle` < 270°, the tolerance angle `tol` extends this range to: 90+tol < `angle` < 270-tol. The angle is normalized to [0, 360). Args: angle: text angle in degrees tol: tolerance range in which text flipping will be avoided v@gV@gp@rnrVtols r4is_upside_down_text_anglerzs+ UNE #: + ++ ++r6c.t||r|dz }|dzS)aReturns a readable (upright) text angle in the range `angle` <= 90+tol or `angle` >= 270-tol. The angle is normalized to [0, 360). Args: angle: text angle in degrees tol: tolerance range in which text flipping will be avoided gf@rw)rzrxs r4upright_text_angler|s!!,  5=r6c|dz|zS)zReturns the distance from baseline to baseline. Args: cap_height: cap height of the line line_spacing: line spacing factor as percentage of 3-on-5 spacing gy&1?rn)r line_spacings r4leadingrs   ,,r6cdfd }tj|jjddjj dS)a\Estimate the width and height of a single column :class:`~ezdxf.entities.MText` entity. This function is faster than the :func:`~ezdxf.tools.text_size.mtext_size` function, but the result is very inaccurate if inline codes are used or line wrapping at the column border is involved! Returns: Tuple[width, height] c4ddlm}jjd}j}|rG|j j jjd}||j|S|jtj|S)Nrr% char_heightr)r) rr&r get_defaultrrr make_fontr DEFAULT_TTF)r&rrrmtexts r4 _make_fontz*estimate_mtext_extents.._make_fontsu%!II11-@ ii JJNN599#8#8#ABE z22uu00ZHHr6rErline_spacing_factor)rr3 column_widthr)r|r{)estimate_mtext_content_extentsr2rrr)rrs` r4estimate_mtext_extentsrsI I * \YY]]7C0!II112GH  r6)\(?c|ay)z7Set the global safety factor for MTEXT size estimation.N_SAFETY_FACTOR)rVs r4set_estimation_safety_factorrs Nr6cday)zbReset the global safety factor for MTEXT size estimation to the hard coded default value. rNrrnr6r4reset_estimation_safety_factorrs Nr6cd}d}|jj}|dkD}t|d}t|rd} |D]q} |j | } | dk(r| rt | |j z} |r(| tj| |z z } t| |} n| dz } t|| }st|||z } || z| | dz zz}|tz|fS)acEstimate the width and height of the :class:`~ezdxf.entities.MText` content string. The result is very inaccurate if inline codes are used or line wrapping at the column border is involved! Column breaks ``\N`` will be ignored. Args: content: the :class:`~ezdxf.entities.MText` content string font: font abstraction based on :class:`ezdxf.tools.fonts.AbstractFont` column_width: :attr:`MText.dxf.width` or 0.0 for an unrestricted column width line_spacing_factor: :attr:`MText.dxf.line_spacing_factor` Returns: tuple[width, height] rT)rrrN) rGrranyr-r space_widthrwceilminmaxrr) rr3rr max_widthrIrhas_column_widthr line_countr line_widthspacings r4rrs,IF))44J)C/'t._scale_leading_number4s -#55 -#55e}# &**$ VFU^,v5HnE(5'&.!122     E s'A AA  AA A.-A.rRrrNNr)rrzrrzr|rz)rHrrr)rrVr old_parts new_partsros ` r4scale_mtext_inline_commandsr1sp3$ G [F e$I%aL>I!" .tU;< 779 r6)rrrTrr|r)rWrrUrr|r)rzUnion[Text, MText]r|ztuple[int, int])r2rzr|rzr)r2rzr|Union[list[str], str]))rrzrrr| list[str])Fr')r2rzrrr|r)u▯)r2rzrrzr|rz)rrzr|r)r2rzr zOptional[float]r zCallable[[str], float]r|r)r2r#r|r)rrzr|rz)rrr$r|rz)r2rzr|r)g@)rVrryrr|r)rVrryrr|r)r+)rrr~rr|r)rr"r|r)rVrr|r}r)rr+) rrzr3r{rrrrr|r)rz Optional[str]rrr|rz)rrzrVrr|rz)dr __future__rtypingrrrrrr r r enumrrw ezdxf.lldxfr r ezdxf.enumsrrrrrrezdxf.lldxf.constrrrrrrr ezdxf.mathrrr ezdxf.colorsrrr ezdxf.entitiesr!r"r#ezdxf.lldxf.tagsr$rr&rr)rbrcrrrrrrrrrrrrr7 JUSTIFIED DISTRIBUTEDr1r0DIGITSr$r&r9 ExceptionrrrIntEnumrrcompilerTrSrbrrsrurzr|rrrrrrrsetrrrnr6r4rs#    (('..55%! j/j/Z .:< dK3\ 1 , 7 77 7t7 Q01 11+1 1h ##R  #!!3""C%%s''    =*=Ho&o&d Y j"j"ZU&U&p   2::< = RZZD E  ! % % & & ' ' * * , ,  f$f$R 3  ,  -@ !$ 2. 2. 2.2. 2.  2.j2='r6