From d0b8c8944555fc6250ff5af04c01acfe37b93e0d Mon Sep 17 00:00:00 2001 From: Hans Hagen Date: Fri, 31 Jan 2003 00:00:00 +0100 Subject: stable 2003.01.31 --- metapost/context/base/metafun.mp | 47 + metapost/context/base/mp-back.mp | 206 ++++ metapost/context/base/mp-butt.mp | 75 ++ metapost/context/base/mp-char.mp | 997 ++++++++++++++++++ metapost/context/base/mp-core.mp | 1116 +++++++++++++++++++++ metapost/context/base/mp-form.mp | 393 ++++++++ metapost/context/base/mp-func.mp | 59 ++ metapost/context/base/mp-grid.mp | 143 +++ metapost/context/base/mp-grph.mp | 290 ++++++ metapost/context/base/mp-page.mp | 421 ++++++++ metapost/context/base/mp-shap.mp | 307 ++++++ metapost/context/base/mp-spec.mp | 555 ++++++++++ metapost/context/base/mp-step.mp | 320 ++++++ metapost/context/base/mp-symb.mp | 351 +++++++ metapost/context/base/mp-text.mp | 250 +++++ metapost/context/base/mp-tool.mp | 2060 ++++++++++++++++++++++++++++++++++++++ metapost/context/metafun.mp | 47 - metapost/context/mp-back.mp | 206 ---- metapost/context/mp-butt.mp | 75 -- metapost/context/mp-char.mp | 997 ------------------ metapost/context/mp-core.mp | 1116 --------------------- metapost/context/mp-form.mp | 393 -------- metapost/context/mp-func.mp | 59 -- metapost/context/mp-grid.mp | 143 --- metapost/context/mp-grph.mp | 290 ------ metapost/context/mp-page.mp | 421 -------- metapost/context/mp-shap.mp | 307 ------ metapost/context/mp-spec.mp | 555 ---------- metapost/context/mp-step.mp | 320 ------ metapost/context/mp-symb.mp | 351 ------- metapost/context/mp-text.mp | 250 ----- metapost/context/mp-tool.mp | 2060 -------------------------------------- 32 files changed, 7590 insertions(+), 7590 deletions(-) create mode 100644 metapost/context/base/metafun.mp create mode 100644 metapost/context/base/mp-back.mp create mode 100644 metapost/context/base/mp-butt.mp create mode 100644 metapost/context/base/mp-char.mp create mode 100644 metapost/context/base/mp-core.mp create mode 100644 metapost/context/base/mp-form.mp create mode 100644 metapost/context/base/mp-func.mp create mode 100644 metapost/context/base/mp-grid.mp create mode 100644 metapost/context/base/mp-grph.mp create mode 100644 metapost/context/base/mp-page.mp create mode 100644 metapost/context/base/mp-shap.mp create mode 100644 metapost/context/base/mp-spec.mp create mode 100644 metapost/context/base/mp-step.mp create mode 100644 metapost/context/base/mp-symb.mp create mode 100644 metapost/context/base/mp-text.mp create mode 100644 metapost/context/base/mp-tool.mp delete mode 100644 metapost/context/metafun.mp delete mode 100644 metapost/context/mp-back.mp delete mode 100644 metapost/context/mp-butt.mp delete mode 100644 metapost/context/mp-char.mp delete mode 100644 metapost/context/mp-core.mp delete mode 100644 metapost/context/mp-form.mp delete mode 100644 metapost/context/mp-func.mp delete mode 100644 metapost/context/mp-grid.mp delete mode 100644 metapost/context/mp-grph.mp delete mode 100644 metapost/context/mp-page.mp delete mode 100644 metapost/context/mp-shap.mp delete mode 100644 metapost/context/mp-spec.mp delete mode 100644 metapost/context/mp-step.mp delete mode 100644 metapost/context/mp-symb.mp delete mode 100644 metapost/context/mp-text.mp delete mode 100644 metapost/context/mp-tool.mp (limited to 'metapost') diff --git a/metapost/context/base/metafun.mp b/metapost/context/base/metafun.mp new file mode 100644 index 000000000..474a10eb3 --- /dev/null +++ b/metapost/context/base/metafun.mp @@ -0,0 +1,47 @@ +%D \module +%D [ file=metafun.mp, +%D version=2000.07.15, +%D title=\CONTEXT\ \METAPOST\ graphics, +%D subtitle=format generation file, +%D author=Hans Hagen, +%D date=\currentdate, +%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] +%C +%C This module is part of the \CONTEXT\ macro||package and is +%C therefore copyrighted by \PRAGMA. See mreadme.pdf for +%C details. + +%D When generating many graphics at runtime, it can save run +%D time to use a format file. We could have named this file +%D \type {context}, but this is error prone, because it forces +%D to use the progname \type {mpost} or \type {context} +%D explicitly, depending on the needs. When using the format, +%D a mismatch in the memory specification of \type {mpost} or +%D \type {context} (the \TEX\ one) could lead to lost strings +%D (and as a result in buggy boundingbox and special +%D handling). By using the name \type {metatex} we make sure +%D that we use (unless overloaded) the settings of \type +%D {mpost}. + +if unknown ahangle : + input plain.mp ; % John Hobby's file +else : + let dump = relax ; +fi ; + +input mp-tool.mp ; +input mp-spec.mp ; +input mp-core.mp ; +input mp-page.mp ; +input mp-text.mp ; +input mp-shap.mp ; +input mp-butt.mp ; +input mp-char.mp ; +input mp-step.mp ; +input mp-grph.mp ; + +% mp-form.mp ; +input mp-grid.mp ; +input mp-func.mp ; + +dump ; endinput . diff --git a/metapost/context/base/mp-back.mp b/metapost/context/base/mp-back.mp new file mode 100644 index 000000000..99e88554b --- /dev/null +++ b/metapost/context/base/mp-back.mp @@ -0,0 +1,206 @@ +%D \module +%D [ file=mp-back.mp, +%D version=2000.05.31, +%D title=\CONTEXT\ \METAPOST\ graphics, +%D subtitle=backgrounds, +%D author=Hans Hagen, +%D date=\currentdate, +%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] +%C +%C This module is part of the \CONTEXT\ macro||package and is +%C therefore copyrighted by \PRAGMA. See licen-en.pdf for +%C details. + +if unknown context_tool : input mp-tool ; fi ; +if known context_back : endinput ; fi ; + +boolean context_back ; context_back := true ; + +def some_hash ( expr hash_width , + hash_height , + hash_linewidth , + hash_linecolor , + hash_angle , + hash_gap ) = + + stripe_gap := hash_gap ; + stripe_angle := hash_angle ; + drawoptions (withpen pencircle scaled hash_linewidth + withcolor hash_linecolor) ; + path p ; p := unitsquare xscaled hash_width yscaled hash_height ; + stripe_path_a () (draw) p ; % next we move it all to quadrant 1 + currentpicture := currentpicture shifted urcorner currentpicture ; + +enddef ; + +def some_double_back (expr back_type , + back_width , + back_height , + back_delta , + back_linewidth , + back_linecolor , + back_fillcolor , + back_topcolor , + back_bottomcolor , + back_leftcolor , + back_rightcolor ) = + + numeric ww ; ww := back_width ; + numeric hh ; hh := back_height ; + numeric dd ; dd := back_delta ; + + color back_nillcolor ; back_nillcolor := back_topcolor ; + + path p ; p := fullsquare xscaled ww yscaled hh ; + path q ; q := fullsquare xscaled (ww-2dd) yscaled (hh-2dd) ; + path r ; r := llcorner p -- + lrcorner p shifted (-3dd,0) .. controls lrcorner p .. + lrcorner p shifted (0, 3dd) -- + urcorner p shifted (0,-3dd) .. controls urcorner p .. + urcorner p shifted (-3dd,0) -- + ulcorner p -- cycle ; + path s ; s := r xscaled ((ww-2dd)/ww) yscaled ((hh-2dd)/hh) ; + path t ; t := llcorner p -- + lrcorner p -- + urcorner p shifted (0,-3dd) .. controls urcorner p .. + urcorner p shifted (-3dd,0) -- + ulcorner p shifted ( 3dd,0) .. controls ulcorner p .. + ulcorner p shifted (0,-3dd) -- + llcorner p -- cycle ; + path u ; u := t xscaled ((ww-2dd)/ww) yscaled ((hh-2dd)/hh) ; + path v ; v := llcorner p shifted ( 3dd,0) -- + lrcorner p shifted (-3dd,0) .. controls lrcorner p .. + lrcorner p shifted (0, 3dd) -- + urcorner p shifted (0,-3dd) .. controls urcorner p .. + urcorner p shifted (-3dd,0) -- + ulcorner p shifted ( 3dd,0) .. controls ulcorner p .. + ulcorner p shifted (0,-3dd) .. + llcorner p shifted (0, 3dd) .. controls llcorner p .. cycle ; % {down} .. cycle ; + path w ; w := t xscaled ((ww-2dd)/ww) yscaled ((hh-2dd)/hh) ; + path a ; a := llcorner p -- ulcorner p -- + ulcorner q -- llcorner q -- cycle ; + path b ; b := llcorner p -- lrcorner p -- + lrcorner q -- llcorner q -- cycle ; + path c ; c := lrcorner p -- urcorner p -- + urcorner q -- lrcorner q -- cycle ; + path d ; d := ulcorner p -- urcorner p -- + urcorner q -- ulcorner q -- cycle ; + path e ; e := llcorner p -- lrcorner p -- + urcorner p -- urcorner q -- + lrcorner q -- llcorner q -- cycle ; + path f ; f := llcorner p -- ulcorner p -- + urcorner p -- urcorner q -- + ulcorner q -- llcorner q -- cycle ; + + linecap := butt ; pickup pencircle scaled back_linewidth ; + + if back_type=1 : + + fill p withcolor back_fillcolor ; + fill a withcolor back_leftcolor ; + fill b withcolor back_bottomcolor ; + fill c withcolor back_rightcolor ; + fill d withcolor back_topcolor ; + draw a withcolor back_linecolor ; + draw d withcolor back_linecolor ; + draw b withcolor back_linecolor ; + draw c withcolor back_linecolor ; + + elseif back_type=2 : + + fill p withcolor back_fillcolor ; + fill e withcolor back_bottomcolor ; + fill f withcolor back_topcolor ; + draw e withcolor back_linecolor ; + draw f withcolor back_linecolor ; + + elseif back_type=3 : + + fill v withcolor back_nillcolor ; + fill w withcolor back_fillcolor ; + draw v withcolor back_linecolor ; + draw w withcolor back_linecolor ; + + elseif back_type=4 : + + fill t withcolor back_nillcolor ; + fill u withcolor back_fillcolor ; + draw t withcolor back_linecolor ; + draw u withcolor back_linecolor ; + + elseif back_type=5 : + + t := t rotatedaround(center t,180) ; + u := u rotatedaround(center u,180) ; + + fill t withcolor back_nillcolor ; + fill u withcolor back_fillcolor ; + draw t withcolor back_linecolor ; + draw u withcolor back_linecolor ; + + elseif back_type=6 : + + r := r rotatedaround(center r,180) ; + s := s rotatedaround(center s,180) ; + + fill r withcolor back_nillcolor ; + fill s withcolor back_fillcolor ; + draw r withcolor back_linecolor ; + draw s withcolor back_linecolor ; + + elseif back_type=7 : + + fill r withcolor back_nillcolor ; + fill s withcolor back_fillcolor ; + draw r withcolor back_linecolor ; + draw s withcolor back_linecolor ; + +fi ; + +enddef ; + +endinput ; + +beginfig (1) ; + +some_double_back (1, 4.5cm, 1.5cm, .25cm, 1mm, + .5white, .8white, .7white, .6white, .7white, .6white) + +currentpicture := currentpicture shifted (0,-3cm) ; + +some_double_back (2, 4.5cm, 1.5cm, .25cm, 1mm, + .5white, .8white, .7white, .6white, white, white) + +currentpicture := currentpicture shifted (0,-3cm) ; + +some_double_back (3, 4.5cm, 1.5cm, .25cm, 1mm, + .5white, .8white, .7white, white, white, white) + +currentpicture := currentpicture shifted (0,-3cm) ; + +some_double_back (4, 4.5cm, 1.5cm, .25cm, 1mm, + .5white, .8white, .7white, white, white, white) + +currentpicture := currentpicture shifted (0,-3cm) ; + +some_double_back (5, 4.5cm, 1.5cm, .25cm, 1mm, + .5white, .8white, .7white, white, white, white) + +currentpicture := currentpicture shifted (0,-3cm) ; + +some_double_back (6, 4.5cm, 1.5cm, .25cm, 1mm, + .5white, .8white, .7white, white, white, white) + +currentpicture := currentpicture shifted (0,-3cm) ; + +some_double_back (7, 4.5cm, 1.5cm, .25cm, 1mm, + .5white, .8white, .7white, white, white, white) + +currentpicture := currentpicture shifted (0,-3cm) ; + +some_double_back (8, 4.5cm, 1.5cm, .25cm, 1mm, + .5white, .8white, .7white, white, white, white) + +endfig ; + +end . diff --git a/metapost/context/base/mp-butt.mp b/metapost/context/base/mp-butt.mp new file mode 100644 index 000000000..cf580211e --- /dev/null +++ b/metapost/context/base/mp-butt.mp @@ -0,0 +1,75 @@ +%D \module +%D [ file=mp-butt.mp, +%D version=2000.05.31, +%D title=\CONTEXT\ \METAPOST\ graphics, +%D subtitle=buttons, +%D author=Hans Hagen, +%D date=\currentdate, +%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] +%C +%C This module is part of the \CONTEXT\ macro||package and is +%C therefore copyrighted by \PRAGMA. See licen-en.pdf for +%C details. + +if unknown context_tool : input mp-tool ; fi ; +if known context_butt : endinput ; fi ; + +boolean context_butt ; context_butt := true ; + +def some_button (expr button_type , + button_size , + button_linecolor , + button_fillcolor ) = + + numeric button_linewidth ; button_linewidth := button_size/10 ; + + drawoptions (withpen pencircle scaled button_linewidth + withcolor button_linecolor) ; + + path p ; p := unitsquare scaled button_size ; + numeric d ; d := button_size ; + numeric l ; l := button_linewidth ; + + fill p withcolor button_fillcolor ; draw p ; + + if button_type=101 : + draw (d-2l,2l)--(2l,.5d)--(d-2l,d-2l)--cycle ; + elseif button_type=102 : + draw (2l,2l)--(d-2l,.5d)--(2l,d-2l)--cycle ; + elseif button_type=103 : + for i=2l step 2l until d-2l : + draw (2l,i)--(2l ,i) ; + draw (4l,i)--(d-2l,i) ; + endfor ; + elseif button_type=104 : + for i=2l step 2l until d-2l : + draw (2l ,i)--(d/2-l,i) ; + draw (d/2+l,i)--(d-2l ,i) ; + endfor ; + elseif button_type=105 : + fill fullcircle scaled (.2d) shifted (.5d,.7d) ; + fill fullcircle xscaled (.6d) yscaled d shifted (.5d,0) ; + clip currentpicture to p ; + draw p ; + elseif button_type=106 : + draw (2l,2l)--(d-2l,d-2l) ; + draw (d-2l,2l)--(2l,d-2l) ; + elseif button_type=107 : + p := (3l,d-2l)--(d-3l,d-2l)--(.5d,4l)--cycle ; + fill p ; draw p ; + draw (.5d,2l) ; + elseif button_type=108 : + draw (.5d,2l)--(d-2l,d-2l)--(2l,d-2l)--cycle ; + elseif button_type=109 : + draw (.5d,d-2l)--(d-2l,2l)--(2l,2l)--cycle ; + elseif button_type=110 : + button_linewidth := button_linewidth/2 ; + draw p enlarged (-2l,-l) ; + for i=2l step l until d-2l : + draw (3l,i)--(d-3l,i) ; + endfor ; + fi ; + +enddef ; + +endinput ; diff --git a/metapost/context/base/mp-char.mp b/metapost/context/base/mp-char.mp new file mode 100644 index 000000000..9416b1349 --- /dev/null +++ b/metapost/context/base/mp-char.mp @@ -0,0 +1,997 @@ +% to be cleaned up, namespace needed ! ! ! ! ! + +%D \module +%D [ file=mp-char.mp, +%D version=1998.10.10, +%D title=\CONTEXT\ \METAPOST\ graphics, +%D subtitle=charts, +%D author=Hans Hagen, +%D date=\currentdate, +%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] +%C +%C This module is part of the \CONTEXT\ macro||package and is +%C therefore copyrighted by \PRAGMA. See licen-en.pdf for +%C details. + +if unknown context_tool : input mp-tool ; fi ; +if unknown context_shap : input mp-shap ; fi ; +if known context_char : endinput ; fi ; + +boolean context_char ; context_char := true ; + +% kan naar elders + +current_position := 0 ; + +def save_text_position (expr p) = % beware: clip shift needed + current_position := current_position + 1 ; + savedata + "\MPposition{" & decimal current_position & "}{" + & decimal xpart p & "}{" + & decimal ypart p & "}" ; +enddef ; + +%D settings + +grid_width := 60pt ; grid_height := 40pt ; +shape_width := 45pt ; shape_height := 30pt ; + +chart_offset := 2pt ; + +color chart_background_color ; chart_background_color := white ; + +%D test mode + +boolean show_mid_points ; show_mid_points := false ; +boolean show_con_points ; show_con_points := false ; +boolean show_all_points ; show_all_points := false ; + +%D shapes + +color shape_line_color, shape_fill_color ; + +shape_line_width := 2pt ; +shape_line_color := .5white ; +shape_fill_color := .9white ; + +shape_node := 0 ; +shape_action := 24 ; +shape_procedure := 5 ; +shape_product := 12 ; +shape_decision := 14 ; +shape_archive := 19 ; +shape_loop := 35 ; +shape_wait := 6 ; +shape_subprocedure := 20 ; shape_sub_procedure := 20 ; +shape_singledocument := 32 ; shape_single_document := 32 ; +shape_multidocument := 33 ; shape_multi_document := 33 ; +shape_right := 66 ; +shape_left := 67 ; +shape_up := 68 ; +shape_down := 69 ; + +% vardef some_shape_path (expr type) == imported from mp-shap + +def show_shapes (expr n) = + + begin_chart(n,8,10) ; + show_con_points := true ; + for i=0 upto 7 : + for j=0 upto 9 : + new_shape(i+1,j+1,i*10+j); + endfor ; + endfor ; + end_chart ; + +enddef ; + +%D connections + +def new_chart = + + color connection_line_color ; + + connection_line_width := shape_line_width ; + connection_line_color := .8white ; + connection_smooth_size := 5pt ; + connection_arrow_size := 4pt ; + connection_dash_size := 3pt ; + + max_x := 6 ; + max_y := 4 ; + + numeric xypoint ; xypoint := 0 ; + + pair xypoints [] ; + + boolean xyfree [][] ; + path xypath [][] ; + numeric xysx [][] ; + numeric xysy [][] ; + color xyfill [][] ; + color xydraw [][] ; + numeric xyline [][] ; + boolean xypeep [][] ; + + numeric cpath ; cpath := 0 ; + path cpaths [] ; + numeric cline [] ; + color ccolor [] ; + boolean carrow [] ; + boolean cdash [] ; + boolean ccross [] ; + + boolean smooth ; smooth := true ; + boolean peepshape ; peepshape := false ; + boolean arrowtip ; arrowtip := true ; + boolean dashline ; dashline := false ; + boolean forcevalid ; forcevalid := false ; + boolean touchshape ; touchshape := false ; + boolean showcrossing ; showcrossing := false ; + + picture dash_pattern ; + + boolean reverse_y ; reverse_y := true ; + +enddef ; + +new_chart ; + +def y_pos (expr y) = + if reverse_y : max_y + 1 - y else : y fi +enddef ; + +def initialize_grid (expr maxx, maxy) = + begingroup ; + save i, j ; + max_x := maxx ; + max_y := maxy ; + dsp_x := 0 ; + dsp_y := 0 ; + for x=1 upto max_x : + for y=1 upto max_y : + xyfree [x][y] := true ; + xyfill [x][y] := shape_fill_color ; + xydraw [x][y] := shape_line_color ; + xyline [x][y] := shape_line_width ; + endfor ; + endfor ; + endgroup ; +enddef ; + +def scaled_to_grid = + xscaled grid_width yscaled grid_height +enddef ; + +def xy_offset (expr x, y) = + (x+.5,y+.5) +enddef ; + +def draw_shape (expr x, yy, p, sx, sy) = + begingroup ; + save y ; + y := y_pos(yy) ; + xypath [x][y] := (p xscaled sx yscaled sy) shifted xy_offset(x,y) ; + xyfree [x][y] := false ; + xysx [x][y] := sx ; + xysy [x][y] := sy ; + xyfill [x][y] := shape_fill_color ; + xydraw [x][y] := shape_line_color ; + xyline [x][y] := shape_line_width ; + xypeep [x][y] := peepshape ; + endgroup ; +enddef ; + +vardef i_point (expr x, y, p, t) = + begingroup ; + save q, ok ; + pair q ; + boolean ok ; + q := xypath[x][y] intersection_point ((p) shifted xy_offset(x,y)) ; + ok := true ; +% if xpart q < -.5 : ok := false ; q := (-.45,ypart q) fi ; +% if xpart q > .5 : ok := false ; q := ( .45,ypart q) fi ; +% if ypart q < -.5 : ok := false ; q := (xpart q,-.45) fi ; +% if ypart q > .5 : ok := false ; q := (xpart q, .45) fi ; + if not ok : + message (t & " of shape (" & decimal x & "," & decimal y & ") limited") ; + fi ; + q + endgroup +enddef ; + +vardef trimmed (expr x, y, z, t) = + if touchshape and t : xyline[x][y]/z else : epsilon fi +enddef ; + +zfactor := 1/3 ; + +vardef xy_bottom (expr x, y, z, t) = + i_point (x, y, ((0,0)--(0,-2)) shifted (zfactor*z*xysx[x][y],0), "bottom") + shifted(0,-trimmed(x,y,grid_height,t)) +enddef ; + +vardef xy_top (expr x, y, z, t) = + i_point (x, y, ((0,0)--(0,2)) shifted (zfactor*z*xysx[x][y],0), "top") + shifted(0,trimmed(x,y,grid_height,t)) +enddef ; + +vardef xy_left (expr x, y, z, t) = + i_point (x, y, ((0,0)--(-2,0)) shifted (0,zfactor*z*xysy[x][y]), "left") + shifted(-trimmed(x,y,grid_width,t),0) +enddef ; + +vardef xy_right (expr x, y, z, t) = + i_point (x, y, ((0,0)--(2,0)) shifted (0,zfactor*z*xysy[x][y]), "right") + shifted(trimmed(x,y,grid_width,t),0) +enddef ; + +def flush_shapes = + for x=1 upto max_x : + for y=1 upto max_y : + flush_shape (x, y) ; + endfor ; + endfor ; +enddef ; + +def draw_connection_point (expr x, y, z) = + pickup pencircle scaled if (z=0): 2 fi xyline[x][y] ; + drawdot xy_bottom(x,y,z,false) scaled_to_grid withcolor (1,0,0) ; + drawdot xy_top (x,y,z,false) scaled_to_grid withcolor (0,1,0) ; + drawdot xy_left (x,y,z,false) scaled_to_grid withcolor (0,0,1) ; + drawdot xy_right (x,y,z,false) scaled_to_grid withcolor (1,1,0) ; +enddef ; + +def flush_shape (expr x, yy) = + begingroup ; + save y ; + y := y_pos(yy) ; + if not xyfree[x][y] : + pickup pencircle scaled xyline[x][y] ; + if xypeep[x][y] : + fill (xypath[x][y] peepholed (unitsquare shifted (x,y))) + scaled_to_grid withpen pencircle scaled 0 + withcolor chart_background_color ; + else : + fill xypath[x][y] scaled_to_grid withcolor xyfill[x][y] ; + fi ; + draw xypath[x][y] scaled_to_grid withcolor xydraw[x][y] ; + if show_con_points or show_all_points : + draw_connection_point (x, y, 0) ; + fi ; + if show_all_points : + for i=-1 upto 1 : + draw_connection_point (x, y, i) ; + endfor ; + fi ; + fi ; + endgroup ; +enddef ; + +vardef points_initialized (expr xfrom, yfrom, xto, yto, n) = + if not xyfree[xfrom][yfrom] and not xyfree[xto][yto] : + xypoint := n ; true + else : + xypoint := 0 ; false + fi +enddef ; + +def collapse_points = % this is now an mp-tool macro + % remove redundant points + n := 1 ; + for i=2 upto xypoint: + if not (xypoints[i]=xypoints[n]) : + n := n + 1 ; + xypoints[n] := xypoints[i] + fi ; + endfor ; + xypoint := n ; + % make straight lines + if xypoints[2]=xypoints[xypoint-1] : + xypoints[3] := xypoints[xypoint] ; + xypoint := 3 ; + fi ; +enddef ; + +vardef smooth_connection (expr a,b) = + sx := connection_smooth_size/grid_width ; + sy := connection_smooth_size/grid_height ; + if ypart a = ypart b : + a shifted (if xpart a >= xpart b : - fi sx,0) +% a shifted (sx*xpart unitvector(b-a),0) + else : + a shifted (0,if ypart a >= ypart b : - fi sy) +% a shifted (0,sy*ypart unitvector(b-a)) + fi +enddef ; + +vardef trim_points = + begingroup + save p, a, b, d, i ; path p ; pair d ; + p := for i=1 upto xypoint-1 : xypoints[i]-- endfor xypoints[xypoint] ; + if touchshape : + a := shape_line_width/grid_width ; + b := shape_line_width/grid_height ; + else : + a := epsilon ; + b := epsilon ; + fi ; + d := direction infinity of p ; + xypoints[xypoint] := xypoints[xypoint] shifted + if xpart d < 0 : (+a,0) ; + elseif xpart d > 0 : (-a,0) ; + elseif ypart d < 0 : (0,+b) ; + elseif ypart d > 0 : (0,-b) ; + else : origin ; + fi ; + d := direction 0 of p ; + xypoints[1] := xypoints[1] shifted + if xpart d < 0 : (-a,0) ; + elseif xpart d > 0 : (+a,0) ; + elseif ypart d < 0 : (0,-b) ; + elseif ypart d > 0 : (0,+b) ; + else : origin ; + fi ; + endgroup +enddef ; + +vardef trim_points = enddef ; + +vardef connection_path = + if reverse_connection : reverse fi (xypoints[1]-- + for i=2 upto xypoint-1 : + if smooth : + smooth_connection(xypoints[i],xypoints[i-1]) .. + controls xypoints[i] and xypoints[i] .. + smooth_connection(xypoints[i],xypoints[i+1]) -- + else : + xypoints[i]-- + fi + endfor + xypoints[xypoint]) +enddef ; + +% vardef connection_path = +% sx := connection_smooth_size/grid_width ; +% sy := connection_smooth_size/grid_height ; +% if reverse_connection : reverse fi +% (for i=1 upto xypoint-1 : xypoints[i] -- endfor xypoints[xypoint]) +% if smooth : cornered max(sx,sy) fi +% enddef ; +% +% primarydef p cornered c = +% if cycle p : +% ((point 0 of p) shifted (c*(unitvector(point 1 of p - point 0 of p))) -- +% for i=1 upto length(p) : +% (point i-1 of p) shifted (c*(unitvector(point i of p - point i-1 of p))) -- +% (point i of p) shifted (c*(unitvector(point i-1 of p - point i of p))) .. +% controls point i of p .. +% endfor cycle) +% else : +% ((point 0 of p) -- +% for i=1 upto length(p)-1 : +% (point i-1 of p) shifted (c*(unitvector(point i of p - point i-1 of p))) -- +% (point i of p) shifted (c*(unitvector(point i-1 of p - point i of p))) .. +% controls point i of p .. +% endfor +% (point length(p) of p)) +% fi +% enddef ; + +def draw_connection = + if xypoint>0 : + collapse_points ; + trim_points ; + cpath := cpath + 1 ; + cpaths[cpath] := connection_path scaled_to_grid ; + cline[cpath] := connection_line_width ; + ccolor[cpath] := connection_line_color ; + carrow[cpath] := arrowtip ; + cdash[cpath] := dashline ; + ccross[cpath] := showcrossing ; + else : + message("no connection defined") ; + fi ; + reverse_connection := false ; +enddef ; + +def flush_connections = + pair ip ; + boolean crossing ; + ahlength := connection_arrow_size ; + dash_pattern := dashpattern(on connection_dash_size off connection_dash_size ) ; + for i=1 upto cpath : + if ccross[i] : + crossing := false ; + for j=1 upto i : + %if not ((point infinity of cpaths[i] = point infinity of cpaths[j]) or + % (point 0 of cpaths[i] = point 0 of cpaths[j])) : + if not (point infinity of cpaths[i] = point infinity of cpaths[j]) : + ip := cpaths[i] intersection_point cpaths[j] ; + if intersection_found : crossing := true fi ; + fi ; + endfor ; + if crossing : + pickup pencircle scaled 2cline[i] ; + %draw cpaths[i] withcolor chart_background_color ; + path cp ; cp := cpaths[i] ; + cp := cp cutbefore point .05 length cp of cp ; + cp := cp cutafter point .95 length cp of cp ; + draw cp withcolor chart_background_color ; + fi ; + fi ; + pickup pencircle scaled cline[i] ; + if carrow[i] : + if cdash[i] : + drawarrow cpaths[i] withcolor ccolor[i] dashed dash_pattern ; + else : + drawarrow cpaths[i] withcolor ccolor[i] ; + fi ; + else : + if cdash[i] : + draw cpaths[i] withcolor ccolor[i] dashed dash_pattern ; + else : + draw cpaths[i] withcolor ccolor[i] ; + fi ; + fi ; + draw_midpoint (i) ; + endfor ; +enddef ; + +def draw_midpoint (expr n) = + begingroup + save p ; + pair p ; + p := point .5*length(cpaths[n]) of cpaths[n]; + pickup pencircle scaled 2cline[n] ; + save_text_position (p) ; + if show_mid_points : + drawdot p withcolor .7white ; + fi ; + endgroup ; +enddef ; + +boolean reverse_connection ; reverse_connection := false ; + +vardef up_on_grid (expr n) = + (xpart xypoints[n],(ypart xypoints[n]+1) div 1) +enddef ; + +vardef down_on_grid (expr n) = + (xpart xypoints[n],(ypart xypoints[n]) div 1) +enddef ; + +vardef left_on_grid (expr n) = + ((xpart xypoints[n]) div 1, ypart xypoints[n]) +enddef ; + +vardef right_on_grid (expr n) = + ((xpart xypoints[n]+1) div 1, ypart xypoints[n]) +enddef ; + +vardef x_on_grid (expr n, xfrom, xto, zfrom) = + if (xfrom=xto) and not (zfrom=0) : + if (zfrom=1) : right_on_grid(2) else : left_on_grid(2) fi + elseif xpart xypoints[1] < xpart xypoints[6] : + right_on_grid(n) + else : + left_on_grid(n) + fi +enddef ; + +vardef y_on_grid (expr n, yfrom, yto, zfrom) = + if (yfrom=yto) and not (zfrom=0) : + if (zfrom=1) : up_on_grid(2) else : down_on_grid(2) fi + elseif ypart xypoints[1] < ypart xypoints[6] : + up_on_grid(n) + else : + down_on_grid(n) + fi +enddef ; + +vardef xy_on_grid (expr n, m) = + (xpart xypoints[n], ypart xypoints[m]) +enddef ; + +vardef down_to_grid (expr a,b) = + (xpart xypoints[a], + ypart xypoints[if ypart xypoints[a]ypart xypoints[b]:a else:b fi]) +enddef ; + +vardef left_to_grid (expr a,b) = + (xpart xypoints[if xpart xypoints[a]xpart xypoints[b]:a else:b fi], + ypart xypoints[a]) +enddef ; + +% vardef boundingboxfraction(expr p, f) = +% ((boundingbox p) enlarged (-f*bbwidth(p),-f*bbheight(p))) +% enddef ; + +vardef valid_connection (expr xfrom, yfrom, xto, yto) = + begingroup ; + save ok, vc, pp ; + boolean ok ; + % check for slanted lines + ok := true ; + for i=1 upto xypoint-1 : + if not ((xpart xypoints[i]=xpart xypoints[i+1]) or + (ypart xypoints[i]=ypart xypoints[i+1])) : ok := false ; + fi ; + endfor ; + if not ok : + %message("slanted"); + false + elseif forcevalid : + %message("force"); + true + elseif (xfrom=xto) and (yfrom=yto) : + %message("self"); + false + else : + % check for crossing shapes + pair vc ; + path pp ; + + pair xyfirst, xylast ; + xyfirst := xypoints[1] ; + xylast := xypoints[xypoint] ; + trim_points ; + pp := for i=1 upto xypoint-1 : xypoints[i]-- endfor xypoints[xypoint] ; + xypoints[1] := xyfirst ; + xypoints[xypoint] := xylast ; + + for i=1 upto max_x : + for j=1 upto max_y : % was bug: xfrom,yto + if not ( ( (i,j)=(xfrom,yfrom) ) or ( (i,j)=(xto,yto) ) ) : + if not xyfree[i][j] : + vc := pp intersection_point xypath[i][j] ; + if intersection_found : ok := false fi ; + fi ; + fi ; + endfor ; + endfor ; + %if not ok: message("crossing") ; fi ; + ok + fi + endgroup +enddef ; + +def connect_top_bottom (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = + yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; + if points_initialized(xfrom,yfrom,xto,yto,6) : + xypoints[1] := xy_top(xfrom,yfrom,zfrom,true) ; + xypoints[6] := xy_bottom(xto,yto,zto,true) ; + xypoints[2] := up_on_grid(1) ; + xypoints[5] := down_on_grid(6) ; + xypoints[3] := up_to_grid(2,5) ; + xypoints[4] := up_to_grid(2,5) ; + if not valid_connection(xfrom,yfrom,xto,yto) : + xypoints[3] := x_on_grid(2,xfrom,xto,zfrom) ; + xypoints[4] := xy_on_grid(3,5) ; + fi ; + %%%% begin experiment + xypoints[3] := xypoints[3] shifted (dsp_x,0) ; + xypoints[4] := xypoints[4] shifted (dsp_x,0) ; + if dsp_y>0 : + xypoints[2] := xypoints[2] shifted (0,dsp_y) ; + xypoints[3] := xypoints[3] shifted (0,dsp_y) ; + elseif dsp_y<0 : + xypoints[4] := xypoints[4] shifted (0,dsp_y) ; + xypoints[5] := xypoints[5] shifted (0,dsp_y) ; + fi + %%%% end experiment + draw_connection ; + fi ; +enddef ; + +def connect_left_right (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = + yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; + if points_initialized(xfrom,yfrom,xto,yto,6) : + xypoints[1] := xy_left(xfrom,yfrom,zfrom,true) ; + xypoints[6] := xy_right(xto,yto,zto,true) ; + xypoints[2] := left_on_grid(1) ; + xypoints[5] := right_on_grid(6) ; + xypoints[3] := left_to_grid(2,5) ; + xypoints[4] := left_to_grid(2,5) ; + if not valid_connection(xfrom,yfrom,xto,yto) : + xypoints[3] := y_on_grid(2,yfrom,yto,zfrom) ; + xypoints[4] := xy_on_grid(5,3) ; + fi ; + draw_connection ; + fi ; +enddef ; + +def connect_left_top (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = + yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; + if points_initialized(xfrom,yfrom,xto,yto,5) : + xypoints[1] := xy_left(xfrom,yfrom,zfrom,true) ; + xypoints[5] := xy_top(xto,yto,zto,true) ; + xypoints[2] := left_on_grid(1) ; + xypoints[4] := up_on_grid(5) ; + xypoints[3] := left_to_grid(2,5) ; + if not valid_connection(xfrom,yfrom,xto,yto) : + xypoints[3] := xy_on_grid(2,4) ; + fi ; + draw_connection ; + fi ; +enddef ; + +def connect_left_bottom (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = + yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; + if points_initialized(xfrom,yfrom,xto,yto,5) : + xypoints[1] := xy_left(xfrom,yfrom,zfrom,true) ; + xypoints[5] := xy_bottom(xto,yto,zto,true) ; + xypoints[2] := left_on_grid(1) ; + xypoints[4] := down_on_grid(5) ; + xypoints[3] := left_to_grid(2,5) ; + if not valid_connection(xfrom,yfrom,xto,yto) : + xypoints[3] := xy_on_grid(2,4) ; + fi ; + draw_connection ; + fi ; +enddef ; + +def connect_right_top (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = + yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; + if points_initialized(xfrom,yfrom,xto,yto,5) : + xypoints[1] := xy_right(xfrom,yfrom,zfrom,true) ; + xypoints[5] := xy_top(xto,yto,zto,true) ; + xypoints[2] := right_on_grid(1) ; + xypoints[4] := up_on_grid(5) ; + xypoints[3] := right_to_grid(2,5) ; + if not valid_connection(xfrom,yfrom,xto,yto) : + xypoints[3] := xy_on_grid(2,4) ; + fi ; + draw_connection ; + fi ; +enddef ; + +def connect_right_bottom (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = + yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; + if points_initialized(xfrom,yfrom,xto,yto,5) : + xypoints[1] := xy_right(xfrom,yfrom,zfrom,true) ; + xypoints[5] := xy_bottom(xto,yto,zto,true) ; + xypoints[2] := right_on_grid(1) ; + xypoints[4] := down_on_grid(5) ; + xypoints[3] := right_to_grid(2,5) ; + if not valid_connection(xfrom,yfrom,xto,yto) : + xypoints[3] := xy_on_grid(2,4) ; + fi ; + %%%% begin experiment + xypoints[2] := xypoints[2] shifted (dsp_x,0) ; + xypoints[3] := xypoints[3] shifted (dsp_x,0) ; + if dsp_y>0 : + xypoints[3] := xypoints[3] shifted (0,-dsp_y) ; + xypoints[4] := xypoints[4] shifted (0,-dsp_y) ; + elseif dsp_y<0 : + xypoints[3] := xypoints[3] shifted (0,dsp_y) ; + xypoints[4] := xypoints[4] shifted (0,dsp_y) ; + fi + %%%% end experiment + draw_connection ; + fi ; +enddef ; + +def connect_left_left (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = + yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; + if points_initialized(xfrom,yfrom,xto,yto,6) : + xypoints[1] := xy_left(xfrom,yfrom,zfrom,true) ; + xypoints[6] := xy_left(xto,yto,zto,true) ; + xypoints[2] := left_on_grid(1) ; + xypoints[5] := left_on_grid(6) ; + xypoints[3] := left_to_grid(2,5) ; + xypoints[4] := left_to_grid(5,2) ; + if not valid_connection(xfrom,yfrom,xto,yto) : + xypoints[3] := y_on_grid(2,yfrom,yto,zfrom) ; + xypoints[4] := xy_on_grid(5,3) ; + fi ; + draw_connection ; + fi ; +enddef ; + +def connect_right_right (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = + yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; + if points_initialized(xfrom,yfrom,xto,yto,6) : + xypoints[1] := xy_right(xfrom,yfrom,zfrom,true) ; + xypoints[6] := xy_right(xto,yto,zto,true) ; + xypoints[2] := right_on_grid(1) ; + xypoints[5] := right_on_grid(6) ; + xypoints[3] := right_to_grid(2,5) ; + xypoints[4] := right_to_grid(5,2) ; + if not valid_connection(xfrom,yfrom,xto,yto) : + xypoints[3] := y_on_grid(2,yfrom,yto,zfrom) ; + xypoints[4] := xy_on_grid(5,3) ; + fi ; + draw_connection ; + fi ; +enddef ; + +def connect_top_top (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = + yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; + if points_initialized(xfrom,yfrom,xto,yto,6) : + xypoints[1] := xy_top(xfrom,yfrom,zfrom,true) ; + xypoints[6] := xy_top(xto,yto,zto,true) ; + xypoints[2] := up_on_grid(1) ; + xypoints[5] := up_on_grid(6) ; + xypoints[3] := up_to_grid(2,5) ; + xypoints[4] := up_to_grid(5,2) ; + if not valid_connection(xfrom,yfrom,xto,yto) : + xypoints[3] := x_on_grid(2,xfrom,xto,zfrom) ; + xypoints[4] := xy_on_grid(3,5) ; + fi ; + draw_connection ; + fi ; +enddef ; + +def connect_bottom_bottom (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = + yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; + if points_initialized(xfrom,yfrom,xto,yto,6) : + xypoints[1] := xy_bottom(xfrom,yfrom,zfrom,true) ; + xypoints[6] := xy_bottom(xto,yto,zto,true) ; + xypoints[2] := down_on_grid(1) ; + xypoints[5] := down_on_grid(6) ; + xypoints[3] := down_to_grid(2,5) ; + xypoints[4] := down_to_grid(5,2) ; + if not valid_connection(xfrom,yfrom,xto,yto) : + xypoints[3] := x_on_grid(2,xfrom,xto,zfrom) ; + xypoints[4] := xy_on_grid(3,5) ; + fi ; + %%%% begin experiment + xypoints[3] := xypoints[3] shifted (dsp_x,0) ; + xypoints[4] := xypoints[4] shifted (dsp_x) ; + if dsp_y<0 : + xypoints[2] := xypoints[2] shifted (0,-dsp_y) ; + xypoints[3] := xypoints[3] shifted (0,-dsp_y) ; + elseif dsp_y>0 : + xypoints[4] := xypoints[4] shifted (0,dsp_y) ; + xypoints[5] := xypoints[5] shifted (0,dsp_y) ; + fi + %%%% end experiment + draw_connection ; + fi ; +enddef ; + +def connect_bottom_top (expr xfrom,yfrom,zfrom) (expr xto,yto,zto) = + reverse_connection := true ; + connect_top_bottom (xto,yto,zto) (xfrom,yfrom,zfrom) ; +enddef ; + +def connect_right_left (expr xfrom,yfrom,zfrom) (expr xto,yto,zto) = + reverse_connection := true ; + connect_left_right (xto,yto,zto) (xfrom,yfrom,zfrom) ; +enddef ; + +def connect_top_left (expr xfrom,yfrom,zfrom) (expr xto,yto,zto) = + reverse_connection := true ; + connect_left_top (xto,yto,zto) (xfrom,yfrom,zfrom) ; +enddef ; + +def connect_bottom_left (expr xfrom,yfrom,zfrom) (expr xto,yto,zto) = + reverse_connection := true ; + connect_left_bottom (xto,yto,zto) (xfrom,yfrom,zfrom) ; +enddef ; + +def connect_top_right (expr xfrom,yfrom,zfrom) (expr xto,yto,zto) = + reverse_connection := true ; + connect_right_top (xto,yto,zto) (xfrom,yfrom,zfrom) ; +enddef ; + +def connect_bottom_right (expr xfrom,yfrom,zfrom) (expr xto,yto,zto) = + reverse_connection := true ; + connect_right_bottom (xto,yto,zto) (xfrom,yfrom,zfrom) ; +enddef ; + +def draw_test_shape (expr x, y) = + draw_shape(x,y,fullcircle, .7, .7) ; +enddef ; + +def draw_test_shapes = + for i=1 upto max_x : + for j=1 upto max_y : + draw_test_shape(i,j) ; + endfor ; + endfor ; +enddef; + +def draw_test_area = + pickup pencircle scaled .5shape_line_width ; + draw (unitsquare xscaled max_x yscaled max_y shifted (1,1)) + scaled_to_grid withcolor blue ; +enddef ; + +def show_connection (expr n, m) = + + begin_chart(100+n,6,6) ; + + draw_test_area ; + + smooth := true ; + arrowtip := true ; + dashline := true ; + + draw_test_shape(2,2) ; draw_test_shape(4,5) ; + draw_test_shape(3,3) ; draw_test_shape(5,1) ; + draw_test_shape(2,5) ; draw_test_shape(1,3) ; + draw_test_shape(6,2) ; draw_test_shape(4,6) ; + + if (m=1) : + connect_top_bottom (2,2,0) (4,5,0) ; + connect_top_bottom (3,3,0) (5,1,0) ; + connect_top_bottom (2,5,0) (1,3,0) ; + connect_top_bottom (6,2,0) (4,6,0) ; + elseif (m=2) : + connect_top_top (2,2,0) (4,5,0) ; + connect_top_top (3,3,0) (5,1,0) ; + connect_top_top (2,5,0) (1,3,0) ; + connect_top_top (6,2,0) (4,6,0) ; + elseif (m=3) : + connect_bottom_bottom (2,2,0) (4,5,0) ; + connect_bottom_bottom (3,3,0) (5,1,0) ; + connect_bottom_bottom (2,5,0) (1,3,0) ; + connect_bottom_bottom (6,2,0) (4,6,0) ; + elseif (m=4) : + connect_left_right (2,2,0) (4,5,0) ; + connect_left_right (3,3,0) (5,1,0) ; + connect_left_right (2,5,0) (1,3,0) ; + connect_left_right (6,2,0) (4,6,0) ; + elseif (m=5) : + connect_left_left (2,2,0) (4,5,0) ; + connect_left_left (3,3,0) (5,1,0) ; + connect_left_left (2,5,0) (1,3,0) ; + connect_left_left (6,2,0) (4,6,0) ; + elseif (m=6) : + connect_right_right (2,2,0) (4,5,0) ; + connect_right_right (3,3,0) (5,1,0) ; + connect_right_right (2,5,0) (1,3,0) ; + connect_right_right (6,2,0) (4,6,0) ; + elseif (m=7) : + connect_left_top (2,2,0) (4,5,0) ; + connect_left_top (3,3,0) (5,1,0) ; + connect_left_top (2,5,0) (1,3,0) ; + connect_left_top (6,2,0) (4,6,0) ; + elseif (m=8) : + connect_left_bottom (2,2,0) (4,5,0) ; + connect_left_bottom (3,3,0) (5,1,0) ; + connect_left_bottom (2,5,0) (1,3,0) ; + connect_left_bottom (6,2,0) (4,6,0) ; + elseif (m=9) : + connect_right_top (2,2,0) (4,5,0) ; + connect_right_top (3,3,0) (5,1,0) ; + connect_right_top (2,5,0) (1,3,0) ; + connect_right_top (6,2,0) (4,6,0) ; + else : + connect_right_bottom (2,2,0) (4,5,0) ; + connect_right_bottom (3,3,0) (5,1,0) ; + connect_right_bottom (2,5,0) (1,3,0) ; + connect_right_bottom (6,2,0) (4,6,0) ; + fi ; + + end_chart ; + +enddef ; + +def show_connections = + for f=1 upto 10 : + show_connection(f,f) ; + endfor ; +enddef ; + +%D charts + +def clip_chart (expr minx, miny, maxx, maxy) = + cmin_x := minx ; + cmax_x := maxx ; + cmin_y := miny ; + cmax_y := maxy ; +enddef ; + +def begin_chart (expr n, maxx, maxy) = + new_chart ; + chart_figure := n ; + chart_scale := 1 ; + if chart_figure>0: beginfig(chart_figure) ; fi ; + initialize_grid (maxx, maxy) ; + bboxmargin := 0 ; + cmin_x := 1 ; + cmax_x := maxx ; + cmin_y := 1 ; + cmax_y := maxy ; +enddef ; + +def end_chart = + flush_shapes ; + flush_connections ; + cmin_x := cmin_x ; + cmax_x := cmin_x+cmax_x ; + cmin_y := cmin_y-1 ; + cmax_y := cmin_y+cmax_y ; + if reverse_y : + cmin_y := y_pos(cmin_y) ; + cmax_y := y_pos(cmax_y) ; + fi ; + path p ; + p := (((cmin_x,cmin_y)--(cmax_x,cmin_y)-- + (cmax_x,cmax_y)--(cmin_x,cmax_y)--cycle)) + scaled_to_grid ; + %draw p withcolor red ; + p := p enlarged chart_offset ; + clip currentpicture to p ; + setbounds currentpicture to p ; + savedata + "\MPclippath{" & + decimal xpart llcorner p & "}{" & + decimal ypart llcorner p & "}{" & + decimal xpart urcorner p & "}{" & + decimal ypart urcorner p & "}" ; + savedata + "\MPareapath{" & + decimal (xpart llcorner p + 2chart_offset) & "}{" & + decimal (ypart llcorner p + 2chart_offset) & "}{" & + decimal (xpart urcorner p - 2chart_offset) & "}{" & + decimal (ypart urcorner p - 2chart_offset) & "}" ; + currentpicture := currentpicture scaled chart_scale ; + if chart_figure>0: endfig ; fi ; +enddef ; + +def new_shape (expr x, y, n) = + if known n : + if (x>0) and (x<=max_x) and (y>0) and (y<=max_y) : + sx := shape_width/grid_width ; + sy := shape_height/grid_height ; + draw_shape(x,y,some_shape_path(n), sx, sy) ; + else : + message ("shape outside grid ignored") ; + fi ; + else + message ("shape not known" ) ; + fi ; +enddef ; + +def begin_sub_chart = + begingroup ; + save shape_line_width , connection_line_width ; + save shape_line_color, shape_fill_color, connection_line_color ; + color shape_line_color, shape_fill_color, connection_line_color ; + save smooth, arrowtip, dashline, peepshape ; + boolean smooth, arrowtip, dashline, peepshape ; +enddef ; + +def end_sub_chart = + endgroup ; +enddef ; + +%D done + +endinput ; + +%D testing + +show_shapes(100) ; + +end + +%D more testing + +show_connections ; + +begin_chart (1,4,5) ; + %clip_chart(1,1,1,2) ; + new_shape (1,1,31) ; + new_shape (1,2,3) ; + new_shape (4,4,5) ; + connect_top_left (1,1,0) (4,4,0) ; + connect_bottom_top (1,2,0) (4,4,0) ; + connect_left_right (1,2,0) (1,1,0) ; +end_chart ; + +end diff --git a/metapost/context/base/mp-core.mp b/metapost/context/base/mp-core.mp new file mode 100644 index 000000000..5f1341a69 --- /dev/null +++ b/metapost/context/base/mp-core.mp @@ -0,0 +1,1116 @@ +%D \module +%D [ file=mp-core.mp, +%D version=2000.something, % 1999.08.12, +%D title=\CONTEXT\ \METAPOST\ graphics, +%D subtitle=core interfacing, +%D author=Hans Hagen, +%D date=\currentdate, +%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] +%C +%C This module is part of the \CONTEXT\ macro||package and is +%C therefore copyrighted by \PRAGMA. See licen-en.pdf for +%C details. + +if unknown context_tool : input mp-tool ; fi ; +if known context_core : endinput ; fi ; + +boolean context_core ; context_core := true ; + +pair lxy[], rxy[], cxy[], llxy[], lrxy[], ulxy[], urxy[] ; +path pxy[] ; +numeric hxy[], wxy[], dxy[], nxy[] ; + +def box_found (expr n,x,y,w,h,d) = + not ((x=0) and (y=0) and (w=0) and (h=0) and (d=0)) +enddef ; + +def initialize_box_pos (expr pos,n,x,y,w,h,d) = + pair lxy, rxy, cxy, llxy, lrxy, ulxy, urxy ; + path pxy ; numeric hxy, wxy, dxy, nxy; + lxy := (x,y) ; + llxy := (x,y-d) ; + lrxy := (x+w,y-d) ; + urxy := (x+w,y+h) ; + ulxy := (x,y+h) ; + wxy := w ; + hxy := h ; + dxy := d ; + rxy := lxy shifted (wxy,0) ; + pxy := llxy--lrxy--urxy--ulxy--cycle ; + cxy := center pxy ; + nxy := n ; + freeze_box(pos) ; +enddef ; + +def freeze_box (expr pos) = + lxy[pos] := lxy ; + llxy[pos] := llxy ; + lrxy[pos] := lrxy ; + urxy[pos] := urxy ; + ulxy[pos] := ulxy ; + wxy[pos] := wxy ; + hxy[pos] := hxy ; + dxy[pos] := dxy ; + rxy[pos] := rxy ; + pxy[pos] := pxy ; + cxy[pos] := cxy ; + nxy[pos] := nxy ; +enddef ; + +def initialize_box (expr n,x,y,w,h,d) = + + numeric bpos ; bpos := 0 ; initialize_box_pos(bpos,n,x,y,w,h,d) ; + +enddef ; + +def initialize_area (expr fn,fx,fy,fw,fh,fd, + tn,tx,ty,tw,th,td) = + + numeric fpos ; fpos := 1 ; initialize_box_pos(fpos,fn,fx,fy,fw,fh,fd) ; + numeric tpos ; tpos := 2 ; initialize_box_pos(tpos,tn,tx,ty,tw,th,td) ; + + do_initialize_area (fpos, tpos) ; + +enddef ; + +def do_initialize_area (expr fpos, tpos) = + lxy := lxy[fpos] ; + llxy := (xpart llxy[fpos], ypart llxy[tpos]) ; + lrxy := lrxy[tpos] ; + urxy := (xpart urxy[tpos], ypart urxy[fpos]) ; + ulxy := ulxy[fpos] ; + wxy := xpart lrxy - xpart llxy ; + hxy := hxy[fpos] ; + dxy := dxy[tpos] ; + rxy := lxy shifted (wxy,0) ; + pxy := llxy--lrxy--urxy--ulxy--cycle ; + cxy := center pxy ; +enddef ; + +def set_par_line_height (expr ph, pd) = + par_strut_height := + if ph>0 : ph elseif StrutHeight>0 : StrutHeight else : 8pt fi ; + par_strut_depth := + if pd>0 : pd elseif StrutDepth >0 : StrutDepth else : 3pt fi ; + par_line_height := + par_strut_height + par_strut_depth ; +enddef ; + +def initialize_par (expr fn,fx,fy,fw,fh,fd, + tn,tx,ty,tw,th,td, + mn,mx,my,mw,mh,md, + pn,px,py,pw,ph,pd, + rw,rl,rr,rh,ra,ri) = + + numeric fpos ; fpos := 1 ; initialize_box_pos(fpos,fn,fx,fy,fw,fh,fd) ; + numeric tpos ; tpos := 2 ; initialize_box_pos(tpos,tn,tx,ty,tw,th,td) ; + numeric mpos ; mpos := 3 ; initialize_box_pos(mpos,mn,mx,my,mw,mh,md) ; + numeric ppos ; ppos := 4 ; initialize_box_pos(ppos,pn,px,py,pw,ph,pd) ; + + numeric par_strut_height, par_strut_depth, par_line_height ; + + set_par_line_height (ph, pd) ; + + do_initialize_area (fpos, tpos) ; + do_initialize_par (fpos, tpos, mpos, ppos, rw,rl,rr,rh,ra,ri) ; + +enddef ; + +def initialize_area_par (expr fn,fx,fy,fw,fh,fd, + tn,tx,ty,tw,th,td, + wn,wx,wy,ww,wh,wd) = + + numeric fpos ; fpos := 1 ; initialize_box_pos(fpos,fn,fx,fy,fw,fh,fd) ; + numeric tpos ; tpos := 2 ; initialize_box_pos(tpos,tn,tx,ty,tw,th,td) ; + numeric wpos ; wpos := 3 ; initialize_box_pos(wpos,wn,wx,wy,ww,wh,wd) ; + + numeric par_strut_height, par_strut_depth, par_line_height ; + + set_par_line_height (wh, wd) ; + + numeric ffpos ; ffpos := 4 ; initialize_box_pos(ffpos,wn,wx,fy,0,wh,wd) ; + numeric ttpos ; ttpos := 5 ; initialize_box_pos(ttpos,wn,wx+ww,ty,0,wh,wd) ; + + do_initialize_area (ffpos, ttpos) ; + + numeric mpos ; mpos := 6 ; freeze_box(mpos) ; + +% do_initialize_area (fpos, tpos) ; + do_initialize_par (fpos, tpos, mpos, ffpos, 0,0,0,0,0,0) ; + +enddef ; + +def do_initialize_par (expr fpos, tpos, mpos, ppos, rw,rl,rr,rh,ra,ri) = + + pair lref, rref, pref, lhref, rhref ; + + % clip the page area to the left and right skips + + llxy[mpos] := llxy[mpos] shifted (+rl,0) ; + lrxy[mpos] := lrxy[mpos] shifted (-rr,0) ; + urxy[mpos] := urxy[mpos] shifted (-rr,0) ; + ulxy[mpos] := ulxy[mpos] shifted (+rl,0) ; + + % fixate the leftskip, rightskip and hanging indentation + + lref := (xpart llxy[mpos],ypart ulxy[ppos]) ; lhref := lref shifted (rh,0) ; + rref := (xpart lrxy[mpos],ypart urxy[ppos]) ; rhref := rref shifted (rh,0) ; + + pref := lxy[ppos] ; + + if nxy[tpos] > nxy[fpos] : + if nxy[fpos] = nxy[mpos] : + % first of multiple pages + llxy[tpos] := llxy[mpos] ; + lrxy[tpos] := lrxy[mpos] ; + urxy[tpos] := lrxy[mpos] shifted (0,par_line_height) ; + ulxy[tpos] := llxy[mpos] shifted (0,par_line_height) ; + boxgriddirection := down ; + elseif nxy[tpos] = nxy[mpos] : + % last of multiple pages + llxy[fpos] := ulxy[mpos] shifted (0,-par_line_height) ; + lrxy[fpos] := urxy[mpos] shifted (0,-par_line_height) ; + urxy[fpos] := urxy[mpos] ; + ulxy[fpos] := ulxy[mpos] ; + boxgriddirection := up ; + else : + % middle of multiple pages + llxy[fpos] := ulxy[mpos] shifted (0,-par_line_height) ; + lrxy[fpos] := urxy[mpos] shifted (0,-par_line_height) ; + urxy[fpos] := urxy[mpos] ; + ulxy[fpos] := ulxy[mpos] ; + llxy[tpos] := llxy[mpos] ; + lrxy[tpos] := lrxy[mpos] ; + urxy[tpos] := lrxy[mpos] shifted (0,par_line_height) ; + ulxy[tpos] := llxy[mpos] shifted (0,par_line_height) ; + boxgriddirection := up ; + fi ; + else : + % just one page + boxgriddirection := up ; + fi ; + + path txy, bxy, pxy, mxy ; + + txy := originpath ; % top + bxy := originpath ; % bottom + pxy := originpath ; % composed + + boolean lefthang, righthang, somehang ; + + % we only hang on the first of a multiple page background + + if nxy[mpos] > nxy[fpos] : + lefthang := righthang := somehang := false ; + else : + lefthang := (rh>0) ; righthang := (rh<0) ; somehang := false ; + fi ; + + if lefthang : + mxy := boundingbox (lref -- lref shifted (rh,ra*par_line_height)) ; + elseif righthang : + mxy := boundingbox (rref -- rref shifted (rh,ra*par_line_height)) ; + else : + mxy := originpath ; + fi ; + + if round(ypart llxy[fpos]) = round(ypart llxy[tpos]) : + + % We have a one-liner. Watch how er use the bottom pos for + % determining the height. + + llxy[fpos] := (xpart llxy[fpos], ypart llxy[tpos]) ; + ulxy[fpos] := (xpart ulxy[fpos], ypart ulxy[tpos]) ; + + else : + + % We have a multi-liner. For convenience we now correct the + % begin and end points for indentation. + + if lefthang and (round(ypart llxy[tpos]) >= round(ypart lrcorner mxy)) : + llxy[tpos] := (xpart lhref, ypart llxy[tpos]) ; + ulxy[tpos] := (xpart lhref, ypart ulxy[tpos]) ; + else : + llxy[tpos] := (xpart lref, ypart llxy[tpos]) ; + ulxy[tpos] := (xpart lref, ypart ulxy[tpos]) ; + fi ; + + if righthang and (round(ypart lrxy[fpos]) >= round(ypart llcorner mxy)) : + lrxy[fpos] := (xpart rhref, ypart lrxy[fpos]) ; + urxy[fpos] := (xpart rhref, ypart urxy[fpos]) ; + else : + lrxy[fpos] := (xpart rref, ypart lrxy[fpos]) ; + urxy[fpos] := (xpart rref, ypart urxy[fpos]) ; + fi ; + + fi ; + + somehang := (ypart ulxy[fpos]>ypart llcorner mxy) and + (ypart llxy[tpos]0 : + left_skip := rl + xpart llxy[wpos] - xpart llxy[ppos] ; + right_skip := rw - left_skip - ww ; + else : + left_skip := rl ; + right_skip := rr ; + fi ; + + path multipar, multipars[] ; + numeric multiref, multirefs[] ; + numeric multiloc, multilocs[] ; % 1=begin 2=between 3=end + + numeric multi_par_pages ; multi_par_pages := nxy[tpos]-nxy[fpos]+1 ; + + ii := 0 ; nn := NOfTextAreas+1 ; nofmultipars := 0 ; + + vardef snapped_multi_pos (expr p) = + if snap_multi_par_tops : + if abs(ypart p - ypart ulcorner multipar) < par_line_height : + (xpart p,ypart ulcorner multipar) + else : + p + fi + else : + p + fi + enddef ; + + % def set_multipar (expr i) = + % ((TextAreas[i] leftenlarged -left_skip) rightenlarged -right_skip) + % enddef ; + + vardef set_multipar (expr i) = + ( (TextAreas[i] leftenlarged -left_skip) rightenlarged (-right_skip + if auto_multi_par_hsize : + rw - bbwidth(TextAreas[i]) fi) ) + enddef ; + + vardef top_multi_par(expr p) = + (round(estimated_par_lines(bbheight(p)*par_line_height))=round(bbheight(p))) + enddef ; + + vardef multi_par_tsc(expr p) = + if top_multi_par(p) : TopSkipCorrection else : 0 fi + enddef ; + + vardef estimated_par_lines (expr h) = + round(h/par_line_height) + enddef ; + + vardef estimated_multi_par_height (expr n, t) = + if round(par_line_height)=0 : + 0 + else : + save ok, h ; boolean ok ; + numeric h ; h := 0 ; + ok := false ; + if (nxy[fpos]=RealPageNumber-1) : + for i := 1 upto NOfSavedTextAreas : + if (InsideSavedTextArea(i,par_start_pos)) : + ok := true ; + h := h + estimated_par_lines(ypart ulxy[fpos] - + ypart llcorner SavedTextAreas[i]) ; + elseif ok : + h := h + estimated_par_lines(bbheight(SavedTextAreas[i])) ; + fi ; + endfor ; + fi ; + if ok : + for i := 1 upto n-1 : + h := h + estimated_par_lines(bbheight(TextAreas[i])) ; + endfor ; + else : + % already: ok := false ; + for i := 1 upto n-1 : + if (InsideTextArea(i,par_start_pos)) : + ok := true ; + h := h + estimated_par_lines(ypart ulxy[fpos] - ypart llcorner TextAreas[i]) ; + elseif ok : + h := h + estimated_par_lines(bbheight(TextAreas[i])) ; + fi ; + endfor ; + fi ; + h + fi + enddef ; + + vardef left_top_hang (expr same_area) = + +par_hang_after := ra + estimated_par_lines(py-fy) ; + + if (par_hang_indent>0) and (par_hang_after<0) and obey_multi_par_hang : + pair _ul_ ; _ul_ := (xpart ulcorner multipar, ypart snapped_multi_pos(ulxy[fpos])); + pair _pa_ ; _pa_ := _ul_ shifted (0,par_hang_after*par_line_height) ; + _pa_ := (xpart _pa_,max(ypart _pa_,ypart llcorner multipar)) ; + if same_area : + _pa_ := (xpart _pa_,max(ypart _pa_,ypart llxy[tpos])) ; + fi ; +% vervalt: + if obey_multi_par_more and (round(par_line_height)>0) : + par_hang_after := min(0,round(par_hang_after + + (ypart urxy[fpos]-ypart _pa_)/par_line_height)) ; + fi ; + (xpart _ul_ + par_hang_indent, ypart lrxy[fpos]) -- + (xpart _ul_ + par_hang_indent, ypart _pa_) -- + (xpart ulcorner multipar, ypart _pa_) + else : + (xpart ulcorner multipar, ypart lrxy[fpos]) + fi + enddef ; + + vardef right_top_hang (expr same_area) = + +par_hang_after := ra - estimated_par_lines(py-fy) ; + + if (par_hang_indent<0) and (par_hang_after<0) and obey_multi_par_hang : + pair _ur_ ; _ur_ := (xpart urcorner multipar, ypart snapped_multi_pos(urxy[fpos])) ; + pair _pa_ ; _pa_ := _ur_ shifted (0,par_hang_after*par_line_height) ; + _pa_ := (xpart _pa_,max(ypart _pa_ -TopSkipCorrection,ypart llcorner multipar)) ; + if same_area : + _pa_ := (xpart _pa_,max(ypart _pa_ -TopSkipCorrection,ypart snapped_multi_pos(ulxy[tpos]))) ; + fi ; + if obey_multi_par_more and (round(par_line_height)>0) : + par_hang_after := min(0,round(par_hang_after + + (ypart urxy[fpos]-ypart _pa_)/par_line_height)) ; + fi ; + (xpart urcorner multipar, ypart _pa_) -- + (xpart _ur_ + par_hang_indent, ypart _pa_) -- + (xpart _ur_ + par_hang_indent, ypart snapped_multi_pos(urxy[fpos])) + else : + (xpart urcorner multipar, ypart snapped_multi_pos(urxy[fpos])) + fi + enddef ; + + vardef x_left_top_hang (expr i, t) = + par_hang_after := min(0,ra + estimated_multi_par_height(i,t)) ; + if (par_hang_indent>0) and (par_hang_after<0) : + pair _ul_ ; _ul_ := ulcorner multipar ; + pair _pa_ ; _pa_ := _ul_ shifted (0,par_hang_after*par_line_height) ; + _pa_ := (xpart _pa_,max(ypart _pa_,ypart llcorner multipar)) ; + +if t : + _pa_ := (xpart _pa_,max(ypart _pa_,ypart llxy[tpos])); +fi ; +if abs(ypart _pa_-ypart llxy[tpos])0) and (par_hang_after>0) and obey_multi_par_hang : + _ll_ := (xpart ulcorner multipar, ypart snapped_multi_pos(ulxy[fpos])) ; + _pa_ := _ll_ shifted (0,-par_hang_after*par_line_height) ; + _pa_ := (xpart _pa_,max(ypart _pa_,ypart llcorner multipar)) ; + if same_area : + _pa_ := (xpart _pa_,max(ypart _pa_,ypart _sa_)) ; + fi ; + if obey_multi_par_more and (round(par_line_height)>0) : + par_hang_after := max(0,round(par_hang_after - + (ypart urxy[fpos]-ypart _pa_)/par_line_height)) ; + fi ; + _pa_ -- + (xpart _pa_ + par_hang_indent,ypart _pa_) -- + (xpart _pa_ + par_hang_indent,ypart _sa_) + else : + (xpart llcorner multipar, ypart _sa_) + fi + enddef ; + + vardef right_bottom_hang (expr same_area) = + pair _lr_, _sa_, _pa_ ; + _sa_ := if same_area : snapped_multi_pos(ulxy[tpos]) else : lrcorner multipar fi ; + if (par_hang_indent<0) and (par_hang_after>0) and obey_multi_par_hang : + _lr_ := (xpart urcorner multipar, ypart snapped_multi_pos(urxy[fpos])) ; + _pa_ := _lr_ shifted (0,-par_hang_after*par_line_height) ; + _pa_ := (xpart _pa_,max(ypart _pa_,ypart lrcorner multipar)) ; + if same_area : + _pa_ := (xpart _pa_,max(ypart _pa_,ypart snapped_multi_pos(ulxy[tpos]))) ; + fi ; + if obey_multi_par_more and (round(par_line_height)>0) : + par_hang_after := max(0,round(par_hang_after - + (ypart urxy[fpos]-ypart _pa_)/par_line_height)) ; + fi ; + (xpart _pa_ + par_hang_indent,ypart _sa_) -- + (xpart _pa_ + par_hang_indent,ypart _pa_) -- + _pa_ + else : + (xpart lrcorner multipar, ypart _sa_) + fi + enddef ; + + vardef x_left_bottom_hang (expr i, t) = + pair _ll_, _sa_, _pa_ ; +if t : + _sa_ := llxy[tpos] ; +else : + _sa_ := llcorner multipar ; +fi ; + if (par_hang_indent>0) and (ra>0) : + par_hang_after := max(0,ra - estimated_multi_par_height(i,t)) ; + _ll_ := ulcorner multipar ; + _pa_ := _ll_ shifted (0,-par_hang_after*par_line_height) ; + _pa_ := (xpart _pa_,max(ypart _pa_,ypart llcorner multipar)) ; + _pa_ := (xpart _pa_,max(ypart _pa_,ypart _sa_)) ; + % we need to compensate for topskip enlarged areas + if abs(ypart _pa_ - ypart _sa_) > par_line_height : + (xpart _pa_ + par_hang_indent,ypart _sa_) -- + (xpart _pa_ + par_hang_indent,ypart _pa_) -- + fi + _pa_ + else : + (xpart llcorner multipar, ypart _sa_) + fi + enddef ; + + vardef x_right_bottom_hang (expr i, t) = + pair _lr_, _sa_, _pa_ ; +if t : + _sa_ := snapped_multi_pos(ulxy[tpos]) ; +else : + _sa_ := llcorner multipar ; +fi ; + if (par_hang_indent<0) and (ra>0) : + par_hang_after := max(0,ra - estimated_multi_par_height(i, t)) ; + _lr_ := urcorner multipar ; + _pa_ := _lr_ shifted (0,-par_hang_after*par_line_height) ; + _pa_ := (xpart _pa_,max(ypart _pa_,ypart lrcorner multipar)) ; + _pa_ := (xpart _pa_,max(ypart _pa_,ypart _sa_)) ; + % we need to compensate for topskip enlarged areas + _pa_ + if abs(ypart _pa_ - ypart _sa_) > par_line_height : + -- (xpart _pa_ + par_hang_indent,ypart _pa_) + -- (xpart _pa_ + par_hang_indent,ypart _sa_) + fi + else : + (xpart lrcorner multipar, ypart _sa_) + fi + enddef ; + + def test_multipar = + multipar := + llcorner multipar -- + urcorner multipar -- + lrcorner multipar -- + ulcorner multipar -- + cycle ; + enddef ; + + % first loop + + for i=1 upto NOfTextAreas : + + TopSkipCorrection := 0 ; + + multipar := set_multipar(i) ; + + % watch how we compensate for negative indentation + + if (nxy[fpos]=RealPageNumber) and (InsideTextArea(i,par_start_pos)) : + + % first one in chain + + ii := i ; + + if (nxy[tpos]=RealPageNumber) and (InsideTextArea(i,llxy[tpos])) : + + % in same area + + nn := i ; + + if compensate_multi_par_topskip and (round(LineHeight-ph-pd)=0) : + + TopSkipCorrection := TopSkip - StrutHeight ; + + if round(ypart ulxy[fpos] + TopSkipCorrection) = + round(ypart ulcorner TextAreas[i]) : + ulxy[fpos] := ulxy[fpos] shifted (0,TopSkipCorrection) ; + urxy[fpos] := urxy[fpos] shifted (0,TopSkipCorrection) ; + else : + TopSkipCorrection := 0 ; + fi ; + + fi ; + + if ypart llxy[fpos] = ypart llxy[tpos] : + + multipar := + llxy[fpos] -- + lrxy[tpos] -- + %urxy[tpos] -- + snapped_multi_pos(urxy[tpos]) -- + %ulxy[fpos] -- + snapped_multi_pos(ulxy[fpos]) -- + cycle ; + + save_multipar (i,1,multipar) ; + + elseif (ypart llxy[fpos] = ypart ulxy[tpos]) and + (xpart llxy[tpos] < xpart llxy[fpos]) : + + % two loners + + multipar := if obey_multi_par_hang : + + right_bottom_hang(true) -- + right_top_hang(true) -- + snapped_multi_pos(urxy[fpos]) -- + lrxy[fpos] -- + + else : + + llxy[fpos] -- + (xpart urcorner multipar, ypart llxy[fpos]) -- + (xpart urcorner multipar, ypart ulxy[fpos]) -- + snapped_multi_pos(ulxy[fpos]) -- + + fi cycle ; + + save_multipar (i,1,multipar) ; + + multipar := set_multipar(i) ; + + multipar := if obey_multi_par_hang : + + left_bottom_hang(true) -- + llxy[tpos] -- + snapped_multi_pos(ulxy[tpos]) -- + left_top_hang(true) -- + + else : + + (xpart llcorner multipar, ypart llxy[tpos]) -- + llxy[tpos] -- + snapped_multi_pos(ulxy[tpos]) -- + (xpart llcorner multipar, ypart ulxy[tpos]) -- + + fi cycle ; + + save_multipar (i,1,multipar) ; + + else : + + multipar := if obey_multi_par_hang : + + left_bottom_hang(true) -- + llxy[tpos] -- + %ulxy[tpos] -- + snapped_multi_pos(ulxy[tpos]) -- + right_bottom_hang(true) -- + right_top_hang(true) -- + %urxy[fpos] -- + snapped_multi_pos(urxy[fpos]) -- + lrxy[fpos] -- + left_top_hang(true) -- + + else : + + (xpart llcorner multipar, ypart llxy[tpos]) -- + llxy[tpos] -- + %ulxy[tpos] -- + snapped_multi_pos(ulxy[tpos]) -- + (xpart lrcorner multipar, ypart ulxy[tpos]) -- + (xpart urcorner multipar, ypart urxy[fpos]) -- + %urxy[fpos] -- + snapped_multi_pos(urxy[fpos]) -- + lrxy[fpos] -- + (xpart ulcorner multipar, ypart lrxy[fpos]) -- + + fi cycle ; + + save_multipar (i,1,multipar) ; + + fi ; + + elseif (nxy[tpos]=RealPageNumber) : + + % outside text area, fall back / test on: pascal werkboek + + multipar := + + llxy[fpos] -- + lrxy[tpos] -- + urxy[tpos] -- + ulxy[fpos] -- cycle ; + + save_multipar (i,1,multipar) ; + + else : + + multipar := if obey_multi_par_hang : + + left_bottom_hang(false) -- + right_bottom_hang(false) -- + right_top_hang(false) -- + %urxy[fpos] -- + snapped_multi_pos(urxy[fpos]) -- + lrxy[fpos] -- + left_top_hang(false) -- + + else : + + llcorner multipar -- + lrcorner multipar -- + (xpart urcorner multipar, ypart urxy[fpos]) -- + %urxy[fpos] -- + snapped_multi_pos(urxy[fpos]) -- + lrxy[fpos] -- + (xpart ulcorner multipar, ypart lrxy[fpos]) -- + + fi cycle ; + + save_multipar (i,1,multipar) ; + + fi ; + + elseif (nxy[tpos]=RealPageNumber) and (InsideTextArea(i,llxy[tpos])) : + + % last one in chain + + nn := i ; + + if obey_multi_par_hang and obey_multi_par_more : + + multipar := + x_left_top_hang(i,true) -- + x_right_top_hang(i,true) -- + x_right_bottom_hang(i,true) -- +% ulxy[tpos] -- +snapped_multi_pos(ulxy[tpos]) -- + llxy[tpos] -- + x_left_bottom_hang(i,true) -- + cycle ; + + else : + + multipar := + ulcorner multipar -- + urcorner multipar -- + (xpart lrcorner multipar, ypart urxy[tpos]) -- +% ulxy[tpos] -- +snapped_multi_pos(ulxy[tpos]) -- + llxy[tpos] -- + (xpart llcorner multipar, ypart llxy[tpos]) -- + cycle ; + + fi ; + + save_multipar (i,3,multipar) ; + + else : + + % handled later + + fi ; + + endfor ; + + % second loop + + for i=ii+1 upto nn-1 : + + % rest of chain / todo : hang + +%if (nxy[fpos]<=RealPageNumber) and (nxy[tpos]>=RealPageNumber) : + + multipar := set_multipar(i) ; + + if obey_multi_par_hang and obey_multi_par_more : + + multipar := + x_left_top_hang(i,false) -- + x_right_top_hang(i,false) -- + x_right_bottom_hang(i,false) -- + x_left_bottom_hang(i,false) -- + cycle ; + + fi ; + + save_multipar(i,2,multipar) ; + +%fi ; + + endfor ; + + if span_multi_column_pars : + endgroup ; + fi ; + +enddef ; + +color boxgridcolor ; boxgridcolor := .8red ; +color boxlinecolor ; boxlinecolor := .8blue ; +color boxfillcolor ; boxfillcolor := .8white ; +numeric boxgridtype ; boxgridtype := 0 ; +numeric boxlinetype ; boxlinetype := 1 ; +numeric boxfilltype ; boxfilltype := 1 ; +pair boxgriddirection ; boxgriddirection := up ; +numeric boxgridwidth ; boxgridwidth := 1pt ; +numeric boxlinewidth ; boxlinewidth := 1pt ; +numeric boxlineradius ; boxlineradius := 0pt ; +numeric boxfilloffset ; boxfilloffset := 0pt ; +numeric boxgriddistance ; boxgriddistance := .5cm ; + +def draw_box = + draw pxy withcolor boxlinecolor withpen pencircle scaled boxlinewidth ; + draw lxy -- rxy withcolor boxlinecolor withpen pencircle scaled boxgridwidth ; +enddef ; + +def draw_par = % 1 2 11 12 + do_draw_par(pxy) ; do_draw_par(txy) ; do_draw_par(bxy) ; + for i = pxy, txy, bxy : + if boxgridtype= 1 : + boxgriddirection := origin ; + draw baseline_grid (i,boxgriddirection,true ) withcolor boxgridcolor ; + elseif boxgridtype= 2 : + boxgriddirection := origin ; + draw baseline_grid (i,boxgriddirection,false) withcolor boxgridcolor ; + elseif boxgridtype=11 : + draw graphic_grid(i,boxgriddistance,boxgriddistance,boxgriddistance/2,boxgriddistance/2) ; + elseif boxgridtype=12 : + draw graphic_grid(i,boxgriddistance,boxgriddistance,0,0) ; + fi ; + endfor ; +enddef ; + +def do_show_par (expr p, r, c) = + if length(p) > 2 : for i=0 upto length(p) : + draw fullcircle scaled r shifted point i of p + withpen pencircle scaled .5pt withcolor c ; + endfor ; fi ; + draw p withpen pencircle scaled .5pt withcolor c ; +enddef ; + +def show_par = + if length(mxy) > 2 : + draw mxy dashed evenly + withpen pencircle scaled .5pt withcolor .5white ; + fi ; + do_show_par(txy, 4pt, .5green) ; + do_show_par(bxy, 6pt, .5blue ) ; + do_show_par(pxy, 8pt, .5red ) ; + draw pref withpen pencircle scaled 2pt ; +enddef ; + +def draw_multi_pars = + for i=1 upto nofmultipars : + do_draw_par(multipars[i]) ; + if boxgridtype= 1 : + draw baseline_grid (multipars[i],up,true ) withcolor boxgridcolor ; + elseif boxgridtype= 2 : + draw baseline_grid (multipars[i],up,false) withcolor boxgridcolor ; + elseif boxgridtype=11 : + draw graphic_grid(multipars[i],boxgriddistance,boxgriddistance,boxgriddistance/2,boxgriddistance/2) ; + elseif boxgridtype=12 : + draw graphic_grid(multipars[i],boxgriddistance,boxgriddistance,0,0) ; + fi ; + endfor ; +enddef ; + +def show_multi_pars = + for i=1 upto nofmultipars : + do_show_par(multipars[i], 6pt, .5blue) ; + endfor ; +enddef ; + +vardef do_draw_par (expr p) = + if (length p>2) and (bbwidth(p)>1) and (bbheight(p)>1) : + save pp ; path pp ; + if (boxlineradius>0) and (boxlinetype=2) : + pp := p cornered boxlineradius ; + else : + pp := p ; + fi ; + if boxfilltype>0 : +if boxfilloffset>0 : + % temporary hack + begingroup ; interim linejoin := mitered ; + filldraw pp withcolor boxfillcolor withpen pencircle scaled (2*boxfilloffset) ; + endgroup ; +else : + fill pp withcolor boxfillcolor ; +fi ; + fi ; + if boxlinetype>0 : + draw pp withcolor boxlinecolor withpen pencircle scaled boxlinewidth ; + fi ; + fi ; +enddef ; + +vardef baseline_grid (expr pxy, pdir, at_baseline) = + if (par_line_height>0) and (bbheight(pxy)>1) and (bbwidth(pxy)>1) and (boxgridwidth>0) : + save i, grid ; picture grid ; pair start ; + def _do_ (expr start) = + draw start -- start shifted (bbwidth(pxy),0) + withpen pencircle scaled boxgridwidth + withcolor boxgridcolor ; + enddef ; + grid := image + ( %fails with inlinespace + % + if pdir=up : + for i = if at_baseline : par_strut_depth else : 0 fi + step par_line_height + until max(bbheight(pxy),par_line_height) : + _do_ (llcorner pxy shifted (0,+i)) ; + endfor ; + else : + for i = if at_baseline : par_strut_height else : 0 fi + step par_line_height + until bbheight(pxy) : + _do_ (ulcorner pxy shifted (0,-i)) ; + endfor ; + fi ; + ) ; + clip grid to pxy ; + grid + else : + nullpicture + fi +enddef ; + +vardef graphic_grid (expr pxy, dx, dy, x, y) = + if (bbheight(pxy)>dy) and (bbwidth(pxy)>dx) and (boxgridwidth>0) : + save grid ; picture grid ; + grid := image + ( for i = xpart llcorner pxy step dx until xpart lrcorner pxy : + draw (i,ypart llcorner pxy) -- (i,ypart ulcorner pxy) + withpen pencircle scaled boxgridwidth ; + endfor ; + for i = ypart llcorner pxy step dy until ypart ulcorner pxy : + draw (xpart llcorner pxy,i) -- (xpart lrcorner pxy,i) + withpen pencircle scaled boxgridwidth ; + endfor ) shifted (x,y) ; + clip grid to pxy ; + grid + else : + nullpicture + fi +enddef ; + +def anchor_box (expr n,x,y,w,h,d) = + currentpicture := currentpicture shifted (-x,-y) ; +enddef ; + +let draw_area = draw_box ; +let anchor_area = anchor_box ; +let anchor_par = anchor_box ; + +endinput ; diff --git a/metapost/context/base/mp-form.mp b/metapost/context/base/mp-form.mp new file mode 100644 index 000000000..b5c06b11a --- /dev/null +++ b/metapost/context/base/mp-form.mp @@ -0,0 +1,393 @@ +% Hans Hagen / October 2000 +% +% This file is mostly a copy from the file format.mp, that +% comes with MetaPost and is written by John Hobby. This file +% is meant to be compatible, but has a few more features, +% controlled by the variables: +% +% fmt_initialize when false, initialization is skipped +% fmt_precision the default accuracy (default=3) +% fmt_separator the pattern separator (default=%) +% fmt_zerocheck activate extra sci notation zero check +% +% instead of a picture, one can format a number in a for TeX +% acceptable input string + +boolean mant_font ; mant_font := true ; % signals graph not to load form + +if known fmt_loaded : expandafter endinput fi ; + boolean fmt_loaded ; fmt_loaded := true ; + +if unknown fmt_precision : + numeric fmt_precision ; fmt_precision := 3 ; +fi ; + +if unknown fmt_initialize : + boolean fmt_initialize ; fmt_initialize := true ; +fi ; + +if unknown fmt_separator : + string fmt_separator ; fmt_separator := "%" ; +fi ; + +if unknown fmt_zerocheck : + boolean fmt_zerocheck ; fmt_zerocheck := false ; +fi ; + +boolean fmt_metapost ; fmt_metapost := true ; % == use old method + +% As said, all clever code is from John, the more stupid +% extensions are mine. The following string variables are +% responsible for the TeX formatting. + +% TeX specs when using TeX instead of pseudo TeX. + +string sFebraise_ ; sFebraise_ := "{" ; +string sFeeraise_ ; sFeeraise_ := "}" ; +string sFebmath_ ; sFebmath_ := "$" ; +string sFeemath_ ; sFeemath_ := "$" ; + +string sFmneg_ ; sFmneg_ := "-" ; +string sFemarker_ ; sFemarker_ := "{\times}10^" ; +string sFeneg_ ; sFeneg_ := "-" ; +string sFe_plus ; sFe_plus := "" ; % "+" + +def sFe_base = Fline_up_("1", sFemarker_) enddef ; + +% Macros for generating typeset pictures of computed numbers +% +% format(f,x) typeset generalized number x using format string f +% Mformat(f,x) like format, but x is in Mlog form (see marith.mp) +% init_numbers(s,m,x,sn,e) choose typeset style given sample sign, mantissa,... +% roundd(x,d) round numeric x to d places right of decimal point +% Fe_base what precedes the exponent for typeset powers of 10 +% Fe_plus plus sign if any for typesetting positive exponents +% Ten_to[] powers of ten for indices 0,1,2,3,4 +% +% New are: +% +% formatstr(f,x) TeX string representing x using format f +% Mformatstr(f,x) like Mformatstr, but x is in Mlog form + +% Other than the above-documented user interface, all +% externally visible names start with F and end with _. + +% Allow big numbers in token lists + +begingroup interim warningcheck := 0 ; + +%%% Load auxiliary macros. + +input string +input marith + +%%% Choosing the Layout %%% + +picture Fmneg_, Femarker_, Feneg_, Fe_base, Fe_plus ; +string Fmfont_, Fefont_ ; +numeric Fmscale_, Fescale_, Feraise_ ; + +% Argument +% +% s is a leading minus sign +% m is a 1-digit mantissa +% x is whatever follows the mantissa +% sn is a leading minus for the exponent, and +% e is a 1-digit exponent. +% +% Numbers in scientific notation are constructed by placing +% these pieces side-by-side; decimal numbers use only m +% and/or s. To get exponents with leading plus signs, assign +% to Fe_plus after calling init_numbers. To do something +% special with a unit mantissa followed by x, assign to +% Fe_base after calling init_numbers. + +vardef init_numbers(expr s, m, x, sn, e) = + Fmneg_ := s ; + for p within m : + Fmfont_ := fontpart p ; + Fmscale_ := xxpart p ; + exitif true ; + endfor + Femarker_ := x ; + Feneg_ := sn ; + for p within e : + Fefont_ := fontpart p ; + Fescale_ := xxpart p ; + Feraise_ := ypart llcorner p ; + exitif true ; + endfor + if fmt_metapost : + Fe_base := Fline_up_("1" infont Fmfont_ scaled Fmscale_, Femarker_) ; + % else : + % sFe_base := Fline_up_("1", sFemarker_) ; + fi ; + Fe_plus := nullpicture ; +enddef ; + +%%% Low-Level Typesetting %%% + +vardef Fmant_(expr x) = %%% adapted by HH %%% + if fmt_metapost : + (decimal abs x infont Fmfont_ scaled Fmscale_) + else : + (decimal abs x) + fi +enddef ; + +vardef Fexp_(expr x) = %%% adapted by HH %%% + if fmt_metapost : + (decimal x infont Fefont_ scaled Fescale_ shifted (0,Feraise_)) + else : + (decimal x) + fi +enddef ; + +vardef Fline_up_(text t_) = %%% adapted by HH %%% + if fmt_metapost : + save p_, c_ ; + picture p_ ; p_ = nullpicture ; + pair c_ ; c_ = (0,0) ; + for q_ = t_ : + addto p_ also q_ if string q_ : infont defaultfont scaled defaultscale fi + shifted c_ ; + c_ := (xpart lrcorner p_, 0) ; + endfor + p_ + else : + "" for q_ = t_ : & q_ endfor + fi +enddef ; + +vardef Fdec_o_(expr x) = %%% adapted by HH %%% + if x<0 : + Fline_up_(if fmt_metapost : Fmneg_ else : sFmneg_ fi, Fmant_(x)) + else : + Fmant_(x) + fi +enddef ; + +vardef Fsci_o_(expr x, e) = %%% adapted by HH %%% + if fmt_metapost : + Fline_up_ + (if x < 0 : Fmneg_,fi + if abs x = 1 : Fe_base else : Fmant_(x), Femarker_ fi, + if e < 0 : Feneg_ else : Fe_plus fi, + Fexp_(abs e)) + else : + Fline_up_ + (if x < 0 : sFmneg_, fi + if abs x = 1 : sFe_base else : Fmant_(x), sFemarker_ fi, + sFebraise_, + if e < 0 : sFeneg_ else : sFe_plus fi, + Fexp_(abs e), + sFeeraise_) + fi +enddef ; + +% Assume prologues=1 implies troff mode. TeX users who want +% prologues on should use some other positive value. The mpx +% file mechanism requires separate input files here. + +if fmt_initialize : %%% adapted by HH + if prologues = 1 : input troffnum else : input texnum fi +fi ; + +%%% Scaling and Rounding %%% + +% Find a pair p where x = xpart p*10**ypart p and either p = +% (0,0) or xpart p is between 1000 and 9999.99999. This is +% the `exponent form' of x. + +vardef Feform_(expr x) = + interim warningcheck := 0 ; + if string x : + Meform(Mlog_str x) + else : + save b, e ; + b = x ; e = 0 ; + if abs b >= 10000 : + (b/10, 1) + elseif b = 0 : + origin + else : + forever : + exitif abs b >= 1000 ; + b := b*10 ; e := e-1 ; + endfor + (b, e) + fi + fi +enddef ; + +% The marith.mp macros include a similar macro Meform that +% converts from `Mlog form' to exponent form. In case +% rounding has made the xpart of an exponent form number too +% large, fix it. + +vardef Feadj_(expr x, y) = + if abs x >= 10000 : (x/10, y+1) else : (x,y) fi +enddef ; + +% Round x to d places right of the decimal point. When d<0, +% round to the nearest multiple of 10 to the -d. + +vardef roundd(expr x, d) = + if abs d > 4 : + if d > 0 : x else : 0 fi + elseif d > 0 : + save i ; i = floor x ; + i + round(Ten_to[d]*(x-i))/Ten_to[d] + else : + round(x/Ten_to[-d])*Ten_to[-d] + fi +enddef ; + +Ten_to0 = 1 ; +Ten_to1 = 10 ; +Ten_to2 = 100 ; +Ten_to3 = 1000 ; +Ten_to4 = 10000 ; + +% Round an exponent form number p to k significant figures. + +primarydef p Fprec_ k = + Feadj_(roundd(xpart p,k-4), ypart p) +enddef ; + +% Round an exponent form number p to k digits right of the +% decimal point. + +primarydef p Fdigs_ k = + Feadj_(roundd(xpart p,k+ypart p), ypart p) +enddef ; + +%%% High-Level Routines %%% + +% The following operators convert z from exponent form and +% produce typeset output: Formsci_ generates scientific +% notation; Formdec_ generates decimal notation; and +% Formgen_ generates whatever is likely to be most compact. + +vardef Formsci_(expr z) = %%% adapted by HH %%% + if fmt_zerocheck and (z = origin) : + Fsci_o_(0,0) + else : + Fsci_o_(xpart z/1000, ypart z + 3) + fi +enddef ; + +vardef Formdec_(expr z) = + if ypart z > 0 : + Formsci_(z) + else : + Fdec_o_ + (xpart z if ypart z >= -4 : + /Ten_to[-ypart z] + else : + for i = ypart z upto -5 : /(10) endfor /10000 + fi) + fi +enddef ; + +vardef Formgen_(expr q) = + clearxy ; (x,y) = q ; + if x = 0 : Formdec_ + elseif y >= -6 : Formdec_ + else : Formsci_ + fi (q) +enddef ; + +def Fset_item_(expr s) = %%% adapted by HH %%% + if s <> "" : + if fmt_metapost : + s infont defaultfont scaled defaultscale, + else : + s, + fi + fi +enddef ; + +% For each format letter, the table below tells how to +% round and typeset a quantity z in exponent form. +% +% e scientific, p significant figures +% p decimal, p digits right of the point +% g decimal or scientific, p sig. figs. +% G decimal or scientific, p digits + +string fmt_[] ; + +fmt_[ASCII "e"] = "Formsci_(z Fprec_ p)" ; +fmt_[ASCII "f"] = "Formdec_(z Fdigs_ p)" ; +fmt_[ASCII "g"] = "Formgen_(z Fprec_ p)" ; +fmt_[ASCII "G"] = "Formgen_(z Fdigs_ p)" ; + +% The format and Mformat macros take a format string f and +% generate typeset output for a numeric quantity x. String f +% should contain a `%' followed by an optional number and one +% of the format letters defined above. The number should be +% an integer giving the precision (default 3). + +vardef isfmtseparator primary c = %%% added by HH %%% + ((c <> fmt_separator) and (c <> "%")) +enddef ; + +vardef dofmt_@#(expr f, x) = %%% adapted by HH %%% + initialize_numbers ; + if f = "" : + if fmt_metapost : nullpicture else : "" fi + else : + interim warningcheck := 0 ; + save k, l, s, p, z ; + pair z ; z = @#(x) ; + % the next adaption is okay + % k = 1 + cspan(f, fmt_separator <> ) ; + % but best is to support both % and fmt_separator + k = 1 + cspan(f, isfmtseparator) ; + % + l-k = cspan(substring(k,infinity) of f, isdigit) ; + p = if l > k : + scantokens substring(k,l) of f + else : + fmt_precision + fi ; + string s ; s = fmt_[ASCII substring (l,l+1) of f] ; + if unknown s : + if k <= length f : + errmessage("No valid format letter found in "&f) ; + fi + s = if fmt_metapost : "nullpicture" else : "" fi ; + fi + Fline_up_ + (Fset_item_(substring (0,k-1) of f) + if not fmt_metapost : sFebmath_, fi + scantokens s, + if not fmt_metapost : sFeemath_, fi + Fset_item_(substring (l+1,infinity) of f) + if fmt_metapost : nullpicture else : "" fi) + fi + hide (fmt_metapost := true) +enddef ; + +%%% so far %%% + +vardef format (expr f, x) = + fmt_metapost := true ; dofmt_.Feform_(f,x) +enddef ; + +vardef Mformat(expr f, x) = + fmt_metapost := true ; dofmt_.Meform (f,x) +enddef ; + +vardef formatstr (expr f, x) = + fmt_metapost := false ; dofmt_.Feform_(f,x) +enddef ; + +vardef Mformatstr(expr f, x) = + fmt_metapost := false ; dofmt_.Meform (f,x) +enddef ; + +% Restore warningcheck to previous value. + +endgroup ; diff --git a/metapost/context/base/mp-func.mp b/metapost/context/base/mp-func.mp new file mode 100644 index 000000000..d8646ef3b --- /dev/null +++ b/metapost/context/base/mp-func.mp @@ -0,0 +1,59 @@ +%D \module +%D [ file=mp-func.mp, +%D version=2001.12.29, +%D title=\CONTEXT\ \METAPOST\ graphics, +%D subtitle=function hacks, +%D author=Hans Hagen, +%D date=\currentdate, +%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] +%C +%C This module is part of the \CONTEXT\ macro||package and is +%C therefore copyrighted by \PRAGMA. See licen-en.pdf for +%C details. + +%D Under construction. + +if unknown context_tool : input mp-tool ; fi ; +if known context_func : endinput ; fi ; + +boolean context_func ; context_func := true ; + +string pathconnectors[] ; + +pathconnectors[0] := "," ; +pathconnectors[1] := "--" ; +pathconnectors[2] := ".." ; +pathconnectors[3] := "..." ; + +vardef function (expr f) (expr u, t, b, e, s) = save x ; numeric x ; + for xx := b step s until e : + hide (x := xx ;) if xx>b : scantokens(pathconnectors[f]) fi + (scantokens(u),scantokens(t)) + endfor +enddef ; + +def punkedfunction = function (1) enddef ; +def curvedfunction = function (2) enddef ; +def tightfunction = function (3) enddef ; + +vardef constructedpath (expr f) (text t) = + save ok ; boolean ok ; ok := false ; + for i=t : + if ok : scantokens(pathconnectors[f]) else : ok := true ; fi i + endfor +enddef ; + +def punkedpath = constructedpath (1) enddef ; +def curvedpath = constructedpath (2) enddef ; +def tightpath = constructedpath (3) enddef ; + +vardef constructedpairs (expr f) (text p) = + save i ; i := -1 ; + forever : exitif unknown p[incr(i)] ; + if i>0 : scantokens(pathconnectors[f]) fi p[i] + endfor +enddef ; + +def punkedpairs = constructedpairs (1) enddef ; +def curvedpairs = constructedpairs (2) enddef ; +def tightpairs = constructedpairs (3) enddef ; diff --git a/metapost/context/base/mp-grid.mp b/metapost/context/base/mp-grid.mp new file mode 100644 index 000000000..cfcc6bc15 --- /dev/null +++ b/metapost/context/base/mp-grid.mp @@ -0,0 +1,143 @@ +%D \module +%D [ file=mp-grid.mp, +%D version=2000.07.10, +%D title=\CONTEXT\ \METAPOST\ graphics, +%D subtitle=grid support, +%D author=Hans Hagen, +%D date=\currentdate, +%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] +%C +%C This module is part of the \CONTEXT\ macro||package and is +%C therefore copyrighted by \PRAGMA. See licen-en.pdf for +%C details. + +%D Under construction. + +if unknown context_tool : input mp-tool ; fi ; +if known context_grid : endinput ; fi ; + +boolean context_grid ; context_grid := true ; + +string fmt_separator ; fmt_separator := "@" ; +numeric fmt_precision ; fmt_precision := 3 ; +boolean fmt_initialize ; fmt_initialize := false ; +boolean fmt_zerocheck ; fmt_zerocheck := true ; + +if unknown fmt_loaded : input mp-form ; fi ; + +boolean fmt_pictures ; fmt_pictures := true ; + +def do_format = if fmt_pictures : format else : formatstr fi enddef ; +def do_mformat = if fmt_pictures : Mformat else : Mformatstr fi enddef ; + +def hlingrid (expr Min, Max, Step, Length, Width) text t = + image ( for i=Min step Step until Max : + draw (origin--(Width,0)) shifted (0,i*(Length/Max)) t ; + endfor ; ) ; +enddef ; + +def vlingrid (expr Min, Max, Step, Length, Height) text t = + image ( for i=Min step Step until Max : + draw (origin--(0,Height)) shifted (i*(Length/Max),0) t ; + endfor ; ) ; +enddef ; + +def hloggrid (expr Min, Max, Step, Length, Width) text t = + image ( for i=max(Min,1) step Step until min(Max,10) : + draw (origin--(Width,0)) shifted (0,Length*log(i)) t ; + endfor ; ) ; +enddef ; + +def vloggrid (expr Min, Max, Step, Length, Height) text t = + image ( for i=max(Min,1) step Step until min(Max,10) : + draw (origin--(0,Height)) shifted (Length*log(i),0) t ; + endfor ; ) ; +enddef ; + +vardef hlintext@#(expr Min, Max, Step, Length, Format) text t = + image ( do_initialize_numbers ; + for i=Min step Step until Max : + draw textext@#(do_format(Format,i)) shifted (0,i*(Length/Max)) t ; + endfor ; ) +enddef ; + +vardef vlintext@#(expr Min, Max, Step, Length, Format) text t = + image ( do_initialize_numbers ; + for i=Min step Step until Max : + draw textext@#(do_format(Format,i)) shifted (i*(Length/Max),0) t ; + endfor ; ) +enddef ; + +vardef hlogtext@#(expr Min, Max, Step, Length, Format) text t = + image ( do_initialize_numbers ; + for i=max(Min,1) step Step until min(Max,10) : + draw textext@#(do_format(Format,i)) shifted (0,Length*log(i)) t ; + endfor ; ) +enddef ; + +vardef vlogtext@#(expr Min, Max, Step, Length, Format) text t = + image ( do_initialize_numbers ; + for i=max(Min,1) step Step until min(Max,10) : + draw textext@#(do_format(Format,i)) shifted (Length*log(i),0) t ; + endfor ; ) +enddef ; + +vardef hlinlabel@#(expr Min, Max, Step, Length) text t = + image ( + for i=Min step Step until Max : + draw thelabel@#(decimal i,(0,i*(Length/Max))) t ; + endfor ; ) +enddef ; + +vardef vlinlabel@#(expr Min, Max, Step, Length) text t = + image ( + for i=Min step Step until Max : + draw thelabel@#(decimal i,(i*(Length/Max),0)) t ; + endfor ; ) +enddef ; + +boolean numbers_initialized ; numbers_initialized := false ; + +def do_initialize_numbers = + if not numbers_initialized : + init_numbers ( textext.raw("$-$") , + textext.raw("$1$") , + textext.raw("${\times}10$") , + textext.raw("${}^-$") , + textext.raw("${}^2$") ) ; + numbers_initialized := true ; + fi ; +enddef ; + +def initialize_numbers = + numbers_initialized := false ; do_initialize_numbers ; +enddef ; + +vardef linlog(expr xy) = ( xpart xy, log(ypart xy)) enddef ; +vardef loglin(expr xy) = (log(xpart xy), ypart xy) enddef ; +vardef loglog(expr xy) = (log(xpart xy), log(ypart xy)) enddef ; +vardef linlin(expr xy) = ( (xpart xy), (ypart xy)) enddef ; + +vardef loglinpath primary p = processpath (p) (loglin) enddef ; +vardef linlogpath primary p = processpath (p) (linlog) enddef ; +vardef loglogpath primary p = processpath (p) (loglog) enddef ; +vardef linlinpath primary p = processpath (p) (linlin) enddef ; + +def processpath (expr p) (text pp) = + if path p : + for i=0 upto length(p)-1 : + (pp(point i of p)) .. controls + (pp(postcontrol i of p)) and + (pp(precontrol (i+1) of p)) .. + endfor + if cycle p : + cycle + else : + (pp(point length(p) of p)) + fi + elseif pair p : + (pp(p)) + else : + p + fi +enddef ; diff --git a/metapost/context/base/mp-grph.mp b/metapost/context/base/mp-grph.mp new file mode 100644 index 000000000..957a60ec8 --- /dev/null +++ b/metapost/context/base/mp-grph.mp @@ -0,0 +1,290 @@ +%D \module +%D [ file=mp-grph.mp, +%D version=2000.12.14, +%D title=\CONTEXT\ \METAPOST\ graphics, +%D subtitle=graphic text support, +%D author=Hans Hagen, +%D date=\currentdate, +%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] +%C +%C This module is part of the \CONTEXT\ macro||package and is +%C therefore copyrighted by \PRAGMA. See licen-en.pdf for +%C details. + +%D Under construction. + +if unknown context_tool : input mp-tool ; fi ; +if known context_grph : endinput ; fi ; + +boolean context_grph ; context_grph := true ; + +string CRLF ; CRLF := char 10 & char 13 ; + +picture _currentpicture_ ; + +def beginfig (expr c) = + begingroup + charcode := c ; + resetfig ; + scantokens extra_beginfig ; +enddef ; + +def resetfig = + clearxy ; + clearit ; + clearpen ; + pickup defaultpen ; + interim linecap := linecap ; + interim linejoin := linejoin ; + interim miterlimit := miterlimit ; + save _background_ ; color _background_ ; _background_ := background ; + save background ; color background ; background := _background_ ; + drawoptions () ; +enddef ; + +def protectgraphicmacros = + save showtext ; + save beginfig ; let beginfig = begingraphictextfig ; + save endfig ; let endfig = endgraphictextfig ; + save end ; let end = relax ; + interim prologues := prologues ; + resetfig ; +enddef ; + +numeric currentgraphictext ; currentgraphictext := 0 ; +string graphictextformat ; graphictextformat := "plain" ; +string graphictextstring ; graphictextstring := "" ; +string graphictextfile ; graphictextfile := "dummy.mpo" ; + +def savegraphictext (expr str) = + graphictextfile := jobname & ".mpo" ; + if (graphictextstring<>"") : + write graphictextstring to graphictextfile ; + graphictextstring := "" ; + fi ; + write str to graphictextfile ; + let erasegraphictextfile = relax ; +enddef ; + +def erasegraphictextfile = + graphictextfile := jobname & ".mpo" ; + write EOF to graphictextfile ; + let erasegraphictextfile = relax ; +enddef ; + +extra_beginfig := extra_beginfig & " erasegraphictextfile ;" ; + +def begingraphictextfig (expr n) = + foundpicture := n ; scratchpicture := nullpicture ; +enddef ; + +def endgraphictextfig = + if foundpicture = currentgraphictext : + expandafter endinput + else : + scratchpicture := nullpicture ; + fi ; +enddef ; + +def loadfigure primary filename = + doloadfigure (filename) +enddef ; + +def doloadfigure (expr filename) text figureattributes = + begingroup ; + save figurenumber, figurepicture, number, fixedplace ; + numeric figurenumber ; figurenumber := 0 ; + boolean figureshift ; figureshift := true ; + picture figurepicture ; figurepicture := currentpicture ; + def number primary n = hide(figurenumber := n) enddef ; + def fixedplace = hide(figureshift := false) enddef ; + protectgraphicmacros ; + % defaults + interim linecap := rounded ; + interim linejoin := rounded ; + interim miterlimit := 10 ; + % + currentpicture := nullpicture ; + draw fullcircle figureattributes ; % expand number + currentpicture := nullpicture ; + def beginfig (expr n) = + currentpicture := nullpicture ; + if (figurenumber=n) or (figurenumber=0) : + let endfig = endinput ; + fi ; + enddef ; + let endfig = relax ; + readfile(filename) ; + if figureshift : + currentpicture := currentpicture shifted -llcorner currentpicture ; + fi ; + addto figurepicture also currentpicture figureattributes ; + currentpicture := figurepicture ; + endgroup ; +enddef ; + +def graphictext primary t = + dographictext(t) +enddef ; + +def dographictext (expr t) = + begingroup ; + if graphictextformat<>"" : + graphictextstring := + "% format=" & graphictextformat & CRLF & graphictextstring ; + graphictextformat := "" ; + fi ; + currentgraphictext := currentgraphictext + 1 ; + savegraphictext ("\startTEXpage[scale=10000]" & t & "\stopTEXpage") ; + dofinishgraphictext +enddef ; + +def redographictext primary t = + regraphictext(t) +enddef ; + +def regraphictext (expr t) = + begingroup ; + save currentgraphictext ; numeric currentgraphictext ; + currentgraphictext := t ; + dofinishgraphictext +enddef ; + +%D Believe it or not, but it took me half a day to uncover +%D the following neccessity: +%D +%D \starttypen +%D save withfillcolor, withdrawcolor ; +%D \stoptypen +%D +%D When we have more than one graphictext, these will be +%D defined after the first graphic. For some obscure reason, +%D this means that in the next graphic they will be called, but +%D afterwards the data and boolean are not set. Don't ask me +%D why. + +def dofinishgraphictext text x_op_x = + protectgraphicmacros ; + interim linecap := butt ; % normally rounded + interim linejoin := mitered ; % normally rounded + interim miterlimit := 10 ; % todo + let normalwithshade = withshade ; + save foundpicture, scratchpicture, str ; + save fill, draw, withshade, reversefill, outlinefill ; + save withfillcolor, withdrawcolor ; % quite important + numeric foundpicture ; picture scratchpicture ; string str ; + def draw expr p = + % the first, naive implementation was: + % addto scratchpicture doublepath p withpen currentpen ; + % but it is better to turn lines into fills + addto scratchpicture contour boundingbox + image (addto currentpicture doublepath p withpen currentpen) ; + enddef ; + def fill expr p = + addto scratchpicture contour p withpen currentpen ; + enddef ; + def f_op_f = enddef ; boolean f_color ; f_color := false ; + def d_op_d = enddef ; boolean d_color ; d_color := false ; + def s_op_s = enddef ; boolean s_color ; s_color := false ; + boolean reverse_fill ; reverse_fill := false ; + boolean outline_fill ; outline_fill := false ; + def reversefill = + hide(reverse_fill := true ) + enddef ; + def outlinefill = + hide(outline_fill := true ) + enddef ; + def withshade primary c = + hide(def s_op_s = normalwithshade c enddef ; s_color := true ) + enddef ; + def withfillcolor primary c = + hide(def f_op_f = withcolor c enddef ; f_color := true ) + enddef ; + def withdrawcolor primary c = + hide(def d_op_d = withcolor c enddef ; d_color := true ) + enddef ; + scratchpicture := nullpicture ; + addto scratchpicture doublepath origin x_op_x ; % pre-roll + for i within scratchpicture : % Below here is a dirty tricky test! + if (urcorner dashpart i) = origin : outline_fill := false ; fi ; + endfor ; + scratchpicture := nullpicture ; + readfile(jobname & ".mpy") ; + scratchpicture := (scratchpicture shifted -llcorner scratchpicture) scaled (1/10) ; + if not d_color and not f_color : d_color := true ; fi + if s_color : d_color := false ; f_color := false ; fi ; + if d_color and not reverse_fill : + for i within scratchpicture : + if f_color and outline_fill : + addto currentpicture doublepath pathpart i _op_ x_op_x f_op_f + dashed nullpicture ; + fi ; + if filled i : + addto currentpicture doublepath pathpart i _op_ x_op_x d_op_d ; + fi ; + endfor ; + fi ; + if f_color : + for i within scratchpicture : + if filled i : + addto currentpicture contour pathpart i _op_ x_op_x f_op_f + withpen pencircle scaled 0 ; + fi ; + endfor ; + fi ; + if d_color and reverse_fill : + for i within scratchpicture : + if filled i : + addto currentpicture doublepath pathpart i _op_ x_op_x d_op_d ; + fi ; + endfor ; + fi ; + if s_color : + for i within scratchpicture : + if filled i : + addto currentpicture contour pathpart i _op_ x_op_x s_op_s ; + fi ; + endfor ; + else : + for i within scratchpicture : + if stroked i : + addto currentpicture doublepath pathpart i _op_ x_op_x d_op_d ; + fi ; + endfor ; + fi ; + endgroup ; +enddef ; + +def resetgraphictextdirective = + graphictextstring := "" ; +enddef ; + +def graphictextdirective text t = + graphictextstring := graphictextstring & t & CRLF ; +enddef ; + +endinput + +% example + +input mp-grph ; + + graphictextformat := "context" ; +% graphictextformat := "plain" ; +% graphictextformat := "latex" ; graphictextdirective "\documentclass[]{article}" ; + +beginfig (1) ; + graphictext + "\vbox{\hsize10cm \input tufte }" + scaled 8 + withdrawcolor blue + withfillcolor red + withpen pencircle scaled 2pt ; +endfig ; + +beginfig(1) ; + loadfigure "gracht.mp" rotated 20 ; + loadfigure "koe.mp" number 1 scaled 2 ; +endfig ; + +end diff --git a/metapost/context/base/mp-page.mp b/metapost/context/base/mp-page.mp new file mode 100644 index 000000000..032844ce3 --- /dev/null +++ b/metapost/context/base/mp-page.mp @@ -0,0 +1,421 @@ +%D \module +%D [ file=mp-page.mp, +%D version=1999.03.10, +%D title=\CONTEXT\ \METAPOST\ graphics, +%D subtitle=page enhancements, +%D author=Hans Hagen, +%D date=\currentdate, +%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] +%C +%C This module is part of the \CONTEXT\ macro||package and is +%C therefore copyrighted by \PRAGMA. See mreadme.pdf for +%C details. + +%D This module is rather preliminary and subjected to +%D changes. + +if unknown context_tool : input mp-tool ; fi ; +if known context_page : endinput ; fi ; + +boolean context_page ; context_page := true ; + +if unknown PageStateAvailable : + boolean PageStateAvailable ; PageStateAvailable := false ; +fi ; + +if unknown OnRightPage : + boolean OnRightPage ; OnRightPage := true ; +fi ; + +if unknown InPageBody : + boolean InPageBody ; InPageBody := false ; +fi ; + +def SaveTextAreas = + path SavedTextAreas [] ; + path SavedTextColumns[] ; + numeric NOfSavedTextAreas ; + numeric NOfSavedTextColumns ; + for i=1 upto NOfTextAreas : + SavedTextAreas[i] := TextAreas[i] ; + endfor ; + for i=1 upto NOfTextColumns : + SavedTextColumns[i] := TextColumns[i] ; + endfor ; + NOfSavedTextAreas := NOfTextAreas ; + NOfSavedTextColumns := NOfTextColumns ; +enddef ; + +def ResetTextAreas = + path TextAreas[], TextColumns[] ; + numeric NOfTextAreas ; NOfTextAreas := 0 ; + numeric NOfTextColumns ; NOfTextColumns := 0 ; + numeric nofmultipars ; nofmultipars := 0 ; + TextAreas[0] := TextColumns[0] := origin -- cycle ; +enddef ; + +ResetTextAreas ; SaveTextAreas ; ; + +def RegisterTextArea (expr x, y, w, h, d) = + begingroup ; save p ; path p ; + p := unitsquare xyscaled(w,h+d) shifted (x,y-d) ; + if NOfTextAreas>0 : + % if needed, concatenate areas + if (round(llcorner TextAreas[NOfTextAreas]) = round(ulcorner p)) and + (round(lrcorner TextAreas[NOfTextAreas]) = round(urcorner p)) : + p := ulcorner TextAreas[NOfTextAreas] -- + urcorner TextAreas[NOfTextAreas] -- + lrcorner p -- + llcorner p -- + cycle ; + else : + NOfTextAreas := NOfTextAreas + 1 ; + fi ; + else : + NOfTextAreas := NOfTextAreas + 1 ; + fi ; + TextAreas[NOfTextAreas] := p ; + if NOfTextColumns>0 : + if (round(xpart llcorner TextColumns[NOfTextColumns]) = round(xpart ulcorner p)) and + (round(xpart lrcorner TextColumns[NOfTextColumns]) = round(xpart urcorner p)) : + p := ulcorner TextColumns[NOfTextColumns] -- + urcorner TextColumns[NOfTextColumns] -- + lrcorner p -- + llcorner p -- + cycle ; + else : + NOfTextColumns := NOfTextColumns + 1 ; + fi ; + else : + NOfTextColumns := NOfTextColumns + 1 ; + fi ; + TextColumns[NOfTextColumns] := p ; + endgroup ; +enddef ; + +%D We store a local area in slot zero. + +def RegisterLocalTextArea (expr x, y, w, h, d) = + TextAreas[0] := TextColumns[0] := unitsquare xyscaled(w,h+d) shifted (x,y-d) ; +enddef ; + +def ResetLocalTextArea = + TextAreas[0] := TextColumns[0] := origin -- cycle ; +enddef ; + +ResetLocalTextArea ; + +vardef InsideTextArea (expr _i_, _xy_) = + ( (round(xpart _xy_) >= round(xpart llcorner TextAreas[_i_])) and + (round(xpart _xy_) <= round(xpart lrcorner TextAreas[_i_])) and + (round(ypart _xy_) >= round(ypart llcorner TextAreas[_i_])) and + (round(ypart _xy_) <= round(ypart urcorner TextAreas[_i_])) ) +enddef ; + +vardef InsideSavedTextArea (expr _i_, _xy_) = + ( (round(xpart _xy_) >= round(xpart llcorner SavedTextAreas[_i_])) and + (round(xpart _xy_) <= round(xpart lrcorner SavedTextAreas[_i_])) and + (round(ypart _xy_) >= round(ypart llcorner SavedTextAreas[_i_])) and + (round(ypart _xy_) <= round(ypart urcorner SavedTextAreas[_i_])) ) +enddef ; + +vardef TextAreaX (expr x) = + numeric _TextAreaX_ ; _TextAreaX_ := 0 ; + for i := 1 upto NOfTextAreas : + if (round(x) >= round(xpart llcorner TextAreas[i])) and + (round(x) <= round(xpart lrcorner TextAreas[i])) : + _TextAreaX_ := xpart llcorner TextAreas[i] ; + fi ; + endfor ; + _TextAreaX_ +enddef ; + +vardef TextAreaY (expr y) = + numeric _TextAreaY_ ; _TextAreaY_ := 0 ; + for i := 1 upto NOfTextAreas : + if (round(y) >= round(ypart llcorner TextAreas[NOfTextAreas])) and + (round(y) <= round(ypart ulcorner TextAreas[NOfTextAreas])) : + _TextAreaY_ := ypart llcorner TextAreas[NOfTextAreas] ; + fi ; + endfor ; + _TextAreaY_ +enddef ; + +vardef TextAreaXY (expr x, y) = + pair _TextAreaXY_ ; _TextAreaXY_ := origin ; + for i := 1 upto NOfTextAreas : + if (round(x) >= round(xpart llcorner TextAreas[i])) and + (round(x) <= round(xpart lrcorner TextAreas[i])) and + (round(y) >= round(ypart llcorner TextAreas[i])) and + (round(y) <= round(ypart ulcorner TextAreas[i])) : + _TextAreaXY_ := llconer TextAreas[i] ; + fi ; + endfor ; + _TextAreaXY_ +enddef ; + +vardef TextAreaW (expr x) = + numeric _TextAreaW_ ; _TextAreaW_ := 0 ; + for i := 1 upto NOfTextAreas : + if (round(x) >= round(xpart llcorner TextAreas[i])) and + (round(x) <= round(xpart lrcorner TextAreas[i])) : + _TextAreaW_ := bbwidth(TextAreas[i]) ; + fi ; + endfor ; + _TextAreaW_ +enddef ; + +vardef TextAreaH (expr y) = + numeric _TextAreaH_ ; _TextAreaH_ := 0 ; + for i := 1 upto NOfTextAreas : + if (round(y) >= round(ypart llcorner TextAreas[i])) and + (round(y) <= round(ypart ulcorner TextAreas[i])) : + _TextAreaH_ := bbheight(TextAreas[i]) ; + fi ; + endfor ; + _TextAreaH_ +enddef ; + +vardef TextAreaWH (expr x, y) = + pair _TextAreaWH_ ; _TextAreaWH_ := origin ; + for i := 1 upto NOfTextAreas : + if (round(x) >= round(xpart llcorner TextAreas[i])) and + (round(x) <= round(xpart lrcorner TextAreas[i])) and + (round(y) >= round(ypart llcorner TextAreas[i])) and + (round(y) <= round(ypart ulcorner TextAreas[i])) : + _TextAreaWH_ := (bbwidth(TextAreas[i]),bbheight(TextAreas[i])) ; + fi ; + endfor ; + _TextAreaWH_ +enddef ; + +PageNumber := 0 ; +PaperHeight := 845.04684pt ; +PaperWidth := 597.50787pt ; +PrintPaperHeight := 845.04684pt ; +PrintPaperWidth := 597.50787pt ; +TopSpace := 71.12546pt ; +BottomSpace := 0.0pt ; +BackSpace := 71.13275pt ; +CutSpace := 0.0pt ; +MakeupHeight := 711.3191pt ; +MakeupWidth := 426.78743pt ; +TopHeight := 0.0pt ; +TopDistance := 0.0pt ; +HeaderHeight := 56.90294pt ; +HeaderDistance := 0.0pt ; +TextHeight := 597.51323pt ; +FooterDistance := 0.0pt ; +FooterHeight := 56.90294pt ; +BottomDistance := 0.0pt ; +BottomHeight := 0.0pt ; +LeftEdgeWidth := 0.0pt ; +LeftEdgeDistance := 0.0pt ; +LeftMarginWidth := 75.58197pt ; +LeftMarginDistance := 11.99829pt ; +TextWidth := 426.78743pt ; +RightMarginDistance := 11.99829pt ; +RightMarginWidth := 75.58197pt ; +RightEdgeDistance := 0.0pt ; +RightEdgeWidth := 0.0pt ; + +PageOffset := 0.0pt ; +PageDepth := 0.0pt ; + +LeftEdge := -4 ; Top := -40 ; +LeftEdgeSeparator := -3 ; TopSeparator := -30 ; +LeftMargin := -2 ; Header := -20 ; +LeftMarginSeparator := -1 ; HeaderSeparator := -10 ; +Text := 0 ; Text := 0 ; +RightMarginSeparator := +1 ; FooterSeparator := +10 ; +RightMargin := +2 ; Footer := +20 ; +RightEdgeSeparator := +3 ; BottomSeparator := +30 ; +RightEdge := +4 ; Bottom := +40 ; + +Margin := LeftMargin ; % obsolete +Edge := LeftEdge ; % obsolete +InnerMargin := RightMargin ; % obsolete +InnerEdge := RightEdge ; % obsolete +OuterMargin := LeftMargin ; % obsolete +OuterEdge := LeftEdge ; % obsolete + +InnerMarginWidth := 0pt ; +OuterMarginWidth := 0pt ; +InnerMarginDistance := 0pt ; +OuterMarginDistance := 0pt ; + +InnerEdgeWidth := 0pt ; +OuterEdgeWidth := 0pt ; +InnerEdgeDistance := 0pt ; +OuterEdgeDistance := 0pt ; + +path Area [][] ; pair Location [][] ; path Field [][] ; path Page ; +numeric HorPos ; numeric Hstep [] ; numeric Hsize [] ; +numeric VerPos ; numeric Vstep [] ; numeric Vsize [] ; + +for VerPos=Top step 10 until Bottom: + for HorPos=LeftEdge step 1 until RightEdge: + Area[HorPos][VerPos] := origin--cycle ; + Area[VerPos][HorPos] := Area[HorPos][VerPos] ; + Location[HorPos][VerPos] := origin ; + Location[VerPos][HorPos] := Location[HorPos][VerPos] ; + Field[HorPos][VerPos] := origin--cycle ; + Field[VerPos][HorPos] := Field[HorPos][VerPos] ; + endfor ; +endfor ; + +% def LoadPageState = +% scantokens "input mp-state.tmp" ; +% enddef ; + +def SwapPageState = + if not OnRightPage : + BackSpace := PaperWidth-MakeupWidth-BackSpace ; + CutSpace := PaperWidth-MakeupWidth-CutSpace ; + i := LeftMarginWidth ; + LeftMarginWidth := RightMarginWidth ; + RightMarginWidth := i ; + i := LeftMarginDistance ; + LeftMarginDistance := RightMarginDistance ; + RightMarginDistance := i ; + i := LeftEdgeWidth ; + LeftEdgeWidth := RightEdgeWidth ; + RightEdgeWidth := i ; + i := LeftEdgeDistance ; + LeftEdgeDistance := RightEdgeDistance ; + RightEdgeDistance := i ; + +% these are now available as ..Width and ..Distance + + Margin := LeftMargin ; + Edge := LeftEdge ; + InnerMargin := RightMargin ; + InnerEdge := RightEdge ; + OuterMargin := LeftMargin ; + OuterEdge := LeftEdge ; + else : + Margin := RightMargin ; + Edge := RightEdge ; + InnerMargin := LeftMargin ; + InnerEdge := LeftEdge ; + OuterMargin := RightMargin ; + OuterEdge := RightEdge ; + fi ; +enddef ; + +def SetPageAreas = + + numeric Vsize[], Hsize[], Vstep[], Hstep[] ; + + Vsize[Top] = TopHeight ; + Vsize[TopSeparator] = TopDistance ; + Vsize[Header] = HeaderHeight ; + Vsize[HeaderSeparator] = HeaderDistance ; + Vsize[Text] = TextHeight ; + Vsize[FooterSeparator] = FooterDistance ; + Vsize[Footer] = FooterHeight ; + Vsize[BottomSeparator] = BottomDistance ; + Vsize[Bottom] = BottomHeight ; + + Vstep[Top] = Vstep[TopSeparator] +Vsize[TopSeparator] ; + Vstep[TopSeparator] = PaperHeight-TopSpace ; + Vstep[Header] = Vstep[TopSeparator] -Vsize[Header] ; + Vstep[HeaderSeparator] = Vstep[Header] -Vsize[HeaderSeparator] ; + Vstep[Text] = Vstep[HeaderSeparator]-Vsize[Text] ; + Vstep[FooterSeparator] = Vstep[Text] -Vsize[FooterSeparator] ; + Vstep[Footer] = Vstep[FooterSeparator]-Vsize[Footer] ; + Vstep[BottomSeparator] = Vstep[Footer] -Vsize[BottomSeparator] ; + Vstep[Bottom] = Vstep[BottomSeparator]-Vsize[Bottom] ; + + Hsize[LeftEdge] = LeftEdgeWidth ; + Hsize[LeftEdgeSeparator] = LeftEdgeDistance ; + Hsize[LeftMargin] = LeftMarginWidth ; + Hsize[LeftMarginSeparator] = LeftMarginDistance ; + Hsize[Text] = MakeupWidth ; + Hsize[RightMarginSeparator] = RightMarginDistance ; + Hsize[RightMargin] = RightMarginWidth ; + Hsize[RightEdgeSeparator] = RightEdgeDistance ; + Hsize[RightEdge] = RightEdgeWidth ; + + Hstep[LeftEdge] = Hstep[LeftEdgeSeparator] -Hsize[LeftEdge] ; + Hstep[LeftEdgeSeparator] = Hstep[LeftMargin] -Hsize[LeftEdgeSeparator] ; + Hstep[LeftMargin] = Hstep[LeftMarginSeparator] -Hsize[LeftMargin] ; + Hstep[LeftMarginSeparator] = Hstep[Text] -Hsize[LeftMarginSeparator] ; + Hstep[Text] = BackSpace ; + Hstep[RightMarginSeparator] = Hstep[Text] +Hsize[Text] ; + Hstep[RightMargin] = Hstep[RightMarginSeparator]+Hsize[RightMarginSeparator] ; + Hstep[RightEdgeSeparator] = Hstep[RightMargin] +Hsize[RightMargin] ; + Hstep[RightEdge] = Hstep[RightEdgeSeparator] +Hsize[RightEdgeSeparator] ; + + for VerPos=Top step 10 until Bottom: + for HorPos=LeftEdge step 1 until RightEdge: + Area[HorPos][VerPos] := unitsquare xscaled Hsize[HorPos] yscaled Vsize[VerPos] ; + Area[VerPos][HorPos] := Area[HorPos][VerPos] ; + Location[HorPos][VerPos] := (Hstep[HorPos],Vstep[VerPos]) ; + Location[VerPos][HorPos] := Location[HorPos][VerPos] ; + Field[HorPos][VerPos] := Area[HorPos][VerPos] shifted Location[HorPos][VerPos] ; + Field[VerPos][HorPos] := Field[HorPos][VerPos] ; + endfor ; + endfor ; + + Page := unitsquare xscaled PaperWidth yscaled PaperHeight ; + +enddef ; + +def BoundPageAreas = + + % pickup pencircle scaled 0pt ; + + bboxmargin := 0 ; setbounds currentpicture to Page ; + +enddef ; + +def StartPage = + + if PageStateAvailable : + LoadPageState ; + SwapPageState ; + fi ; + + SetPageAreas ; + BoundPageAreas ; + +enddef ; + +def StopPage = + + BoundPageAreas ; + +enddef ; + +def OverlayBox = + (unitsquare xyscaled (OverlayWidth,OverlayHeight)) +enddef ; + +% handy + +def innerenlarged = + hide(LoadPageState) + if OnRightPage : leftenlarged else : rightenlarged fi +enddef ; + +def outerenlarged = + hide(LoadPageState) + if OnRightPage : rightenlarged else : leftenlarged fi +enddef ; + +% obsolete + +def llEnlarged (expr p,d) = (llcorner p shifted (-d,-d)) enddef ; +def lrEnlarged (expr p,d) = (lrcorner p shifted (+d,-d)) enddef ; +def urEnlarged (expr p,d) = (urcorner p shifted (+d,+d)) enddef ; +def ulEnlarged (expr p,d) = (ulcorner p shifted (-d,+d)) enddef ; + +def Enlarged (expr p, d) = + (llEnlarged (p,d) -- + lrEnlarged (p,d) -- + urEnlarged (p,d) -- + ulEnlarged (p,d) -- cycle) +enddef ; + +endinput ; diff --git a/metapost/context/base/mp-shap.mp b/metapost/context/base/mp-shap.mp new file mode 100644 index 000000000..0f5fe431d --- /dev/null +++ b/metapost/context/base/mp-shap.mp @@ -0,0 +1,307 @@ +%D \module +%D [ file=mp-shap.mp, +%D version=2000.05.31, +%D title=\CONTEXT\ \METAPOST\ graphics, +%D subtitle=shapes, +%D author=Hans Hagen, +%D date=\currentdate, +%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] +%C +%C This module is part of the \CONTEXT\ macro||package and is +%C therefore copyrighted by \PRAGMA. See licen-en.pdf for +%C details. + +if unknown context_tool : input mp-tool ; fi ; +if known context_shap : endinput ; fi ; + +boolean context_shap ; context_shap := true ; + +vardef some_shape_path (expr type) = + + begingroup ; + + save border, xradius, yradius, + normal, mirror, rotate, + lc, rc, tc, bc, ll, lr, ur, ul, + llx, lrx, urx, ulx, lly, lry, ury, uly ; + + path border ; + + xradius := .15 ; xxradius := .10 ; + yradius := .15 ; yyradius := .10 ; + + pair ll ; ll := llcorner (unitsquare shifted (-.5,-.5)) ; + pair lr ; lr := lrcorner (unitsquare shifted (-.5,-.5)) ; + pair ur ; ur := urcorner (unitsquare shifted (-.5,-.5)) ; + pair ul ; ul := ulcorner (unitsquare shifted (-.5,-.5)) ; + + pair llx ; llx := ll shifted (xradius,0) ; + pair lly ; lly := ll shifted (0,yradius) ; + + pair lrx ; lrx := lr shifted (-xradius,0) ; + pair lry ; lry := lr shifted (0,yradius) ; + + pair urx ; urx := ur shifted (-xradius,0) ; + pair ury ; ury := ur shifted (0,-yradius) ; + + pair ulx ; ulx := ul shifted (xradius,0) ; + pair uly ; uly := ul shifted (0,-yradius) ; + + pair llxx ; llxx := ll shifted (xxradius,0) ; + pair llyy ; llyy := ll shifted (0,yyradius) ; + + pair lrxx ; lrxx := lr shifted (-xxradius,0) ; + pair lryy ; lryy := lr shifted (0,yyradius) ; + + pair urxx ; urxx := ur shifted (-xxradius,0) ; + pair uryy ; uryy := ur shifted (0,-yyradius) ; + + pair ulxx ; ulxx := ul shifted (xxradius,0) ; + pair ulyy ; ulyy := ul shifted (0,-yyradius) ; + + pair lc ; lc := ll shifted (0,.5) ; + pair rc ; rc := lr shifted (0,.5) ; + pair tc ; tc := ul shifted (.5,0) ; + pair bc ; bc := ll shifted (.5,0) ; + + def mirror (expr p) = + p rotatedaround(origin,180) + enddef ; + + def normal (expr p ) = + p + enddef ; + + def rotate (expr p) = + p rotated 45 + enddef ; + + if type= 0 : + border := normal (origin--cycle) ; + + elseif type= 5 : + border := normal (llx--lrx{right}...rc...{left}urx--ulx{left}...lc...{right}cycle) ; + elseif type= 6 : + border := normal (ll--lrx{right}...rc...{left}urx--ul--cycle) ; + elseif type= 7 : + border := mirror (ll--lrx{right}...rc...{left}urx--ul--cycle) ; + elseif type= 8 : + border := normal (lr--ury{up}...tc...{down}uly--ll--cycle) ; + elseif type= 9 : + border := mirror (lr--ury{up}...tc...{down}uly--ll--cycle) ; + elseif type=10 : + border := normal (ll--lr--ur--ul--ll--ur--ul--ll--cycle) ; + elseif type=11 : + border := normal (ll--lr--ur--ul--ll--lr--ul--ll--cycle) ; + elseif type=12 : + border := normal (ll--lrx--ur--ulx--cycle) ; + elseif type=13 : + border := normal (llx--lr--urx--ul--cycle) ; + elseif type=14 : + border := normal (lly--bc--lry--ury--tc--uly--cycle) ; + elseif type=15 : + border := normal (llx--lrx--rc--urx--ulx--lc--cycle) ; + elseif type=16 : + border := normal (ll--lrx--rc--urx--ul--cycle) ; + elseif type=17 : + border := mirror (ll--lrx--rc--urx--ul--cycle) ; + elseif type=18 : + border := normal (lr--ury--tc--uly--ll--cycle) ; + elseif type=19 : + border := mirror (lr--ury--tc--uly--ll--cycle) ; + elseif type=20 : + border := normal (ll--lr--ur--ul--ll--llxx--ulxx--ul--ll-- + lr--ur--urxx--lrxx--cycle) ; + elseif type=21 : + border := normal (ul--ll--lr--ur--ul--ulyy--uryy--ur--ul-- + ll--lr--lryy--llyy--cycle) ; + elseif type=22 : + border := normal (ll--lrx--lry--ur--ulx--uly--cycle) ; + elseif type=23 : + border := normal (llx--lr--ury--urx--ul--lly--cycle) ; + elseif type=24 : + border := normal (ll--lr--ur--ul--cycle) ; + elseif type=25 : + border := normal (llx--lrx--lry--ury--urx--ulx--uly--lly--cycle) ; + elseif type=26 : + border := normal (ll--lrx--lry--ur--ul--cycle) ; + elseif type=27 : + border := mirror (ll--lr--ury--urx--ul--cycle) ; + elseif type=28 : + border := normal (ll--lr--ury--urx--ul--cycle) ; + elseif type=29 : + border := mirror (ll--lrx--lry--ur--ul--cycle) ; + elseif type=30 : + border := rotate (bc{right}...{up}rc...tc{left}...{down}lc...{right}bc & + bc--tc & tc{left}..{down}lc & lc--rc & + rc{up}..tc{left}...{down}lc...{right}bc & cycle) ; + elseif type=31 : + border := normal (bc{right}...{up}rc...tc{left}...{down}lc...{right}bc & + bc--tc & tc{left}..{down}lc & lc--rc & + rc{up}..tc{left}...{down}lc...{right}bc & cycle) ; + elseif type=32 : + border := normal (ll{right}...{right}lry--ur--ul--ll--cycle) ; + elseif type=33 : + border := normal (ll{right}...{right}lry--ur--ul--ll--cycle + --ul--ulx--ulx shifted(0,yyradius) + --ur shifted(yyradius,yyradius) + --lry shifted(yyradius,yyradius) + --lry shifted(0,yyradius) + --ur--ul--cycle ) ; + elseif type=34 : + border := normal (uly..tc..ury & + ury..tc shifted (0,-2yradius)..uly & + uly--lly & + lly..bc..lry & + lry--ury & + ury..tc shifted (0,-2yradius)..uly & cycle ) ; + elseif type=35 : + border := normal (bc{right}...rc{up}...tc{left}...lc{down}...cycle) ; + elseif type=36 : + border := normal (ul--tc{right}..rc{down}..{left}bc--ll & + ll..(xpart llx, ypart lc)..ul & cycle) ; + elseif type=37 : + border := mirror (ul--tc{right}..rc{down}..{left}bc--ll & + ll..(xpart llx, ypart lc)..ul & cycle) ; + elseif type=38 : + border := normal (ll--lc{up}..tc{right}..{down}rc--lr & + lr..(xpart bc, ypart lly)..ll & cycle) ; + elseif type=39 : + border := mirror (ll--lc{up}..tc{right}..{down}rc--lr & + lr..(xpart bc, ypart lly)..ll & cycle) ; + elseif type=40 : + border := normal (ll--lr--ur--ul--ll--ur--ul--ll--lr--ul--ll--cycle) ; + elseif type=41 : + border := normal (ll--lr--ur--ul--ll--lr--rc--lc--ll--bc--tc--ul--ll & cycle) ; + elseif type=42 : + border := normal (ll--lr--origin shifted (+epsilon,0)-- + ur--ul--origin shifted (-epsilon,0)--cycle) ; + elseif type=43 : + border := normal (ll--ul--origin shifted (0,+epsilon)-- + ur--lr--origin shifted (0,-epsilon)--cycle) ; + elseif type=45 : + border := normal (bc--rc--tc--lc--cycle) ; + elseif type=46 : + border := normal (ll--ul--rc--cycle) ; + elseif type=47 : + border := mirror (ll--ul--rc--cycle) ; + elseif type=48 : + border := mirror (ul--ur--bc--cycle) ; + elseif type=49 : + border := normal (ul--ur--bc--cycle) ; + + elseif type=56 : + border := normal (ll--lry--ury--ul--cycle) ; + elseif type=57 : + border := mirror (ll--lry--ury--ul--cycle) ; + elseif type=58 : + border := normal (ll--ulx--urx--lr--cycle) ; + elseif type=59 : + border := mirror (ll--ulx--urx--lr--cycle) ; + + elseif type=61 : + border := normal (fullcircle scaled (1.5*yradius) xscaled (grid_height/grid_width)) ; + elseif type=62 : + border := normal (fullcircle scaled (2.0*yradius) xscaled (grid_height/grid_width)) ; + + elseif type=66 : + border := normal (rc--origin shifted ( epsilon,0) --cycle & + rc--origin --cycle ) ; + elseif type=67 : + border := normal (lc--origin shifted (-epsilon,0) --cycle & + lc--origin --cycle ) ; + elseif type=68 : + border := normal (tc--origin shifted (0, epsilon) --cycle & + tc--origin --cycle ) ; + elseif type=69 : + border := normal (bc--origin shifted (0,-epsilon) --cycle & + bc--origin --cycle ) ; + + elseif type=75 : + border := mirror (lly--lry--ury--uly--cycle) ; + elseif type=76 : + border := mirror (ll--lr--ur--uly--cycle) ; + elseif type=77 : + border := mirror (ll--lr--ury--ul--cycle) ; + elseif type=78 : + border := mirror (lly--lr--ur--ul--cycle) ; + elseif type=79 : + border := mirror (ll--lry--ur--ul--cycle) ; + + else : + border := normal (origin--cycle) ; + %border := normal (ll--lr--ur--ul--cycle) ; + fi ; + + border + + endgroup + +enddef; + +def some_shape ( expr shape_type , + shape_width , + shape_height , + shape_linewidth , + shape_linecolor , + shape_fillcolor ) = + + path p ; p := + some_shape_path (shape_type) + xscaled shape_width + yscaled shape_height ; + + pickup pencircle scaled shape_linewidth ; + + fill p withcolor shape_fillcolor ; + draw p withcolor shape_linecolor ; + +enddef ; + +vardef drawshape (expr t, p, lw, lc, fc) = + save pp ; + if t>1 : % normal shape + path pp ; + pp := some_shape_path(t) xyscaled(bbwidth(p), bbheight(p)) shifted center p ; + fill pp withcolor fc ; + draw pp withpen pencircle scaled lw withcolor lc ; + elseif t=1 : % background only + path pp ; + pp := fullsquare xyscaled(bbwidth(p), bbheight(p)) shifted center p ; + fill pp withcolor fc ; + else : % dimensions only + picture pp ; pp := nullpicture ; + setbounds pp to fullsquare xyscaled(bbwidth(p), bbheight(p)) shifted center p ; + draw pp ; + fi ; +enddef ; + +vardef drawline (expr t, p, lw, lc) = + if (t>0) and (length(p)>1) : + saveoptions ; + drawoptions(withpen pencircle scaled lw withcolor lc) ; + draw p ; + if t = 1 : + draw arrowheadonpath(p,1) ; + elseif t = 2 : + draw arrowheadonpath(reverse p,1) ; + elseif t = 3 : + for $ = p,reverse p : draw arrowheadonpath($,1) ; endfor ; + elseif t = 11 : + draw arrowheadonpath(p,1/2) ; + elseif t = 12 : + draw arrowheadonpath(reverse p,1/2) ; + elseif t = 13 : + for $=p,reverse p : draw arrowheadonpath($,1) ; endfor ; + for $=p,reverse p : draw arrowheadonpath($,3/4) ; endfor ; + elseif t = 21 : + for $=1/5,1/2,4/5 : draw arrowheadonpath(p,$) ; endfor ; + elseif t = 22 : + for $=1/5,1/2,4/5 : draw arrowheadonpath(reverse p,$) ; endfor ; + elseif t = 23 : + for $=p,reverse p : draw arrowheadonpath($,1/4) ; endfor ; + fi ; + fi ; +enddef ; + +endinput ; diff --git a/metapost/context/base/mp-spec.mp b/metapost/context/base/mp-spec.mp new file mode 100644 index 000000000..10118f2c0 --- /dev/null +++ b/metapost/context/base/mp-spec.mp @@ -0,0 +1,555 @@ +%D \module +%D [ file=mp-spec.mp, +%D version=1999.6.26, +%D title=\CONTEXT\ \METAPOST\ graphics, +%D subtitle=special extensions, +%D author=Hans Hagen, +%D date=\currentdate, +%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] +%C +%C This module is part of the \CONTEXT\ macro||package and is +%C therefore copyrighted by \PRAGMA. See licen-en.pdf for +%C details. + +% Spot colors are not handled by mptopdf ! + +% (r,g,b) => cmyk : r=123 g= 1 b=hash +% => spot : r=123 g= 2 b=hash +% => transparent rgb : r=123 g= 3 b=hash +% => transparent cmyk : r=123 g= 4 b=hash +% => transparent spot : r=123 g= 5 b=hash +% => rest : r=123 g=n>10 b=whatever + +%D This module is rather preliminary and subjected to +%D changes. Here we closely cooperates with the \METAPOST\ +%D to \PDF\ converter module built in \CONTEXT\ and provides +%D for instance shading. More information can be found in +%D type {supp-mpe.tex}. + +if unknown context_tool : input mp-tool ; fi ; +if known context_spec : endinput ; fi ; + +boolean context_spec ; context_spec := true ; + +numeric _special_counter_ ; _special_counter_ := 0 ; +numeric _color_counter_ ; _color_counter_ := 11 ; % < 10 reserved +numeric _special_signal_ ; _special_signal_ := 123 ; + +%D When set to \type {true}, shading will be supported. Some +%D day I will also write an additional directive. + +boolean _inline_specials_ ; _inline_specials_ := false ; + +%D Because we want to output only those specials that are +%D actually used in a figure, we need a bit complicated +%D bookkeeping and collection of specials. At the cost of some +%D obscurity, we now have rather efficient resources. + +string _global_specials_ ; _global_specials_ := "" ; +string _local_specials_ ; _local_specials_ := "" ; + +vardef add_special_signal = % write the version number + if (length _global_specials_>0) or (length _local_specials_ >0) : + special ("%%MetaPostSpecials: 1.0 " & decimal _special_signal_ ) ; + fi ; +enddef ; + +vardef add_extra_specials = + scantokens _global_specials_ ; + scantokens _local_specials_ ; +enddef ; + +vardef reset_extra_specials = + % only local ones + _local_specials_ := "" ; +enddef ; + +boolean insidefigure ; insidefigure := false ; + +% todo: alleen als special gebruikt flush + +extra_beginfig := + " insidefigure := true ; " & + " reset_extra_specials ; " & + extra_beginfig ; + +extra_endfig := + " add_special_signal ; " & + extra_endfig & + " add_extra_specials ; " & + " reset_extra_specials ; " & + " insidefigure := false ; " ; + +def set_extra_special (expr s) = + if insidefigure : + _local_specials_ := _local_specials_ & s ; + else : + _global_specials_ := _global_specials_ & s ; + fi +enddef ; + +def flush_special (expr typ, siz, dat) = + _special_counter_ := _special_counter_ + 1 ; + if _inline_specials_ : + set_extra_special + ( "special " + & "(" & ditto + & dat & " " + & decimal _special_counter_ & " " + & decimal typ & " " + & decimal siz + & " special" + & ditto & ");" ) ; + else : + set_extra_special + ( "special " + & "(" & ditto + & "%%MetaPostSpecial: " + & decimal siz & " " + & dat & " " + & decimal _special_counter_ & " " + & decimal typ + & ditto & ");" ) ; + fi ; +enddef ; + +%D The next hack is needed in case you use a version of +%D \METAPOST\ that does not provide you the means to configure +%D the buffer size. Patrick Gundlach suggested to use arrays +%D in this case. + +boolean bufferhack ; bufferhack := false ; % true ; + +if bufferhack : + + string _global_specials_[] ; numeric _nof_global_specials_ ; + string _local_specials_[] ; numeric _nof_local_specials_ ; + + _nof_global_specials_ := _nof_local_specials_ := 0 ; + + vardef add_special_signal = % write the version number + if (_nof_global_specials_>0) or (_nof_local_specials_>0) : + special ("%%MetaPostSpecials: 1.0 " & decimal _special_signal_ ) ; + fi ; + enddef ; + + vardef add_extra_specials = + for i=1 upto _nof_global_specials_ : + scantokens _global_specials_[i] ; + endfor; + for i=1 upto _nof_local_specials_ : + scantokens _local_specials_[i] ; + endfor; + enddef ; + + vardef reset_extra_specials = + string _local_specials_[] ; _nof_local_specials_ := 0 ; + enddef ; + + def set_extra_special (expr s) = + if insidefigure : + _local_specials_[incr(_nof_local_specials_)] := s ; + else : + _global_specials_[incr(_nof_global_specials_)] := s ; + fi + enddef ; + +fi ; + +%D So far for this hack. + +%D Shade allocation. + +newinternal shadefactor ; shadefactor := 1 ; + +pair shadeoffset ; shadeoffset := origin ; + +vardef define_linear_shade (expr a, b, ca, cb) = + flush_special(30, 15, "0 1 " & decimal shadefactor & " " & + dddecimal ca & " " & ddecimal (a shifted shadeoffset) & " " & + dddecimal cb & " " & ddecimal (b shifted shadeoffset) ) ; + _special_counter_ +enddef ; + +vardef define_circular_shade (expr a, b, ra, rb, ca, cb) = + flush_special(31, 17, "0 1 " & decimal shadefactor & " " & + dddecimal ca & " " & ddecimal (a shifted shadeoffset) & " " & decimal ra & " " & + dddecimal cb & " " & ddecimal (b shifted shadeoffset) & " " & decimal rb ) ; + _special_counter_ +enddef ; + +%D A few predefined shading macros. + +boolean trace_shades ; trace_shades := false ; + +% if (n=1) : a := llcorner p ; b := urcorner p ; +% elseif (n=2) : a := llcorner p ; b := ulcorner p ; +% elseif (n=3) : a := lrcorner p ; b := ulcorner p ; +% else : a := llcorner p ; b := lrcorner p ; +% fi ; + +def set_linear_vector (suffix a,b)(expr p,n) = + if (n=1) : a := llcorner p ; + b := urcorner p ; + elseif (n=2) : a := lrcorner p ; + b := ulcorner p ; + elseif (n=3) : a := urcorner p ; + b := llcorner p ; + elseif (n=4) : a := ulcorner p ; + b := lrcorner p ; + elseif (n=5) : a := .5[ulcorner p,llcorner p] ; + b := .5[urcorner p,lrcorner p] ; + elseif (n=6) : a := .5[llcorner p,lrcorner p] ; + b := .5[ulcorner p,urcorner p] ; + elseif (n=7) : a := .5[lrcorner p,urcorner p] ; + b := .5[llcorner p,ulcorner p] ; + elseif (n=8) : a := .5[urcorner p,ulcorner p] ; + b := .5[lrcorner p,llcorner p] ; + else : a := .5[ulcorner p,llcorner p] ; + b := .5[urcorner p,lrcorner p] ; + fi ; +enddef ; + +def linear_shade (expr p, n, ca, cb) = + begingroup ; + save a, b, sh ; pair a, b ; + set_linear_vector(a,b)(p,n) ; + fill p withshade define_linear_shade (a,b,ca,cb) ; + if trace_shades : + drawarrow a -- b withpen pencircle scaled 1pt ; + fi ; + endgroup ; +enddef ; + +vardef predefined_linear_shade (expr p, n, ca, cb) = + save a, b, sh ; pair a, b ; + set_linear_vector(a,b)(p,n) ; + set_shade_vector(a,b)(p,n) ; + define_linear_shade (a,b,ca,cb) +enddef ; + +def set_circular_vector (suffix ab, r)(expr p,n) = + if (n=1) : ab := llcorner p ; + elseif (n=2) : ab := lrcorner p ; + elseif (n=3) : ab := urcorner p ; + elseif (n=4) : ab := ulcorner p ; + else : ab := center p ; r := .5r ; + fi ; +enddef ; + +def circular_shade (expr p, n, ca, cb) = + begingroup ; + save ab, r ; pair ab ; numeric r ; + r := (xpart lrcorner p - xpart llcorner p) ++ + (ypart urcorner p - ypart lrcorner p) ; + set_circular_vector(ab,r)(p,n) ; + fill p withshade define_circular_shade(ab,ab,0,r,ca,cb) ; + if trace_shades : + drawarrow ab -- ab shifted (0,r) withpen pencircle scaled 1pt ; + fi ; + endgroup ; +enddef ; + +vardef predefined_circular_shade (expr p, n, ca, cb) = + save ab, r ; pair ab ; numeric r ; + r := (xpart lrcorner p - xpart llcorner p) ++ + (ypart urcorner p - ypart lrcorner p) ; + set_circular_vector(ab,r)(p,n) ; + define_circular_shade(ab,ab,0,r,ca,cb) +enddef ; + +%D Since a \type {fill p withshade s} syntax looks better +%D than some macro, we implement a new primary. + +primarydef p withshade sc = % == p withcolor shadecolor(sh) + hide (_color_counter_ := _color_counter_ + 1) + p withcolor (_special_signal_/1000,_color_counter_/1000,sc/1000) +enddef ; + +vardef shadecolor(expr sc) = + hide (_color_counter_ := _color_counter_ + 1) + (_special_signal_/1000,_color_counter_/1000,sc/1000) +enddef ; + +%D Figure inclusion. + +%numeric cef ; cef := 0 ; + +def externalfigure primary filename = + doexternalfigure (filename) +enddef ; + +def doexternalfigure (expr filename) text transformation = + begingroup ; save p, t ; picture p ; transform t ; + p := nullpicture ; t := identity transformation ; + flush_special(10, 9, + dddecimal (xxpart t, yxpart t, xypart t) & " " & + dddecimal (yypart t, xpart t, ypart t) & " " & filename) ; + addto p contour unitsquare scaled 0 ; + setbounds p to unitsquare transformed t ; + _color_counter_ := _color_counter_ + 1 ; + draw p withcolor (_special_signal_/1000,_color_counter_/1000,_special_counter_/1000) ; +%draw p withcolor (_special_signal_/1000,cef/1000,_special_counter_/1000) ; + endgroup ; +enddef ; + +%D Experimental: + +%numeric currenthyperlink ; currenthyperlink := 0 ; + +def hyperlink primary t = dohyperlink(t) enddef ; +def hyperpath primary t = dohyperpath(t) enddef ; + +def dohyperlink (expr destination) text transformation = + begingroup ; save somepath ; path somepath ; + somepath := fullsquare transformation ; + dohyperpath(destination) somepath ; + endgroup ; +enddef ; + +def dohyperpath (expr destination) expr somepath = + begingroup ; + flush_special(20, 7, + ddecimal (xpart llcorner somepath, ypart llcorner somepath) & " " & + ddecimal (xpart urcorner somepath, ypart urcorner somepath) & " " & destination) ; +% currenthyperlink := currenthyperlink + 1 ; + _color_counter_ := _color_counter_ + 1 ; + fill boundingbox unitsquare scaled 0 withcolor + (_special_signal_/1000,_color_counter_/1000,_special_counter_/1000) ; +% (_special_signal_/1000,currenthyperlink/1000,_special_counter_/1000) ; + endgroup ; +enddef ; + +% \setupinteraction[state=start] +% \setupcolors [state=start] +% +% Hello There! \blank +% +% \startMPcode +% pickup pencircle scaled 5 ; +% draw fullcircle scaled 4cm withcolor red ; +% hyperpath "nextpage" boundingbox currentpicture ; +% draw origin withcolor blue ; +% \stopMPcode +% +% \blank Does it work or not? +% +% \startMPcode +% pickup pencircle scaled 5 ; +% draw fullcircle scaled 4cm withcolor red ; +% hyperpath "nextpage" fullcircle scaled 4cm ; +% draw origin withcolor blue ; +% draw fullcircle scaled 4cm shifted (1cm,1cm); +% \stopMPcode +% +% \blank Does it work or not? \page Hello There! \blank +% +% \startMPcode +% pickup pencircle scaled 5 ; +% draw fullcircle scaled 2cm shifted (-2cm,-1cm) ; +% draw fullcircle scaled 3cm shifted (2cm,1cm) withcolor red ; +% draw fullcircle scaled 1cm ; +% hyperlink "previouspage" scaled 3cm shifted (2cm,1cm) ; +% draw origin withcolor blue ; +% \stopMPcode +% +% \blank Does it work or not? + +_cmyk_counter_ := 0 ; + +extra_endfig := " resetcmykcolors ; " & extra_endfig ; + +def resetcmykcolors = + numeric cmykcolorhash[][][][] ; +enddef ; + +resetcmykcolors ; boolean cmykcolors ; cmykcolors := false ; % true + +string cmykcolorpattern[] ; % needed for transparancies + +vardef cmyk(expr c,m,y,k) = + if cmykcolors : + save ok ; boolean ok ; + if unknown cmykcolorhash[c][m][y][k] : + ok := false ; % not yet defined + elseif cmykcolorhash[c][m][y][k] = -1 : + ok := false ; % locally defined and undefined + else : + ok := true ; % globally already defined + fi ; + if not ok : + save s ; string s ; s := dddecimal (c,m,y) & " " & decimal k ; + _cmyk_counter_ := _cmyk_counter_ + 1 ; + cmykcolorpattern[_cmyk_counter_/1000] := s ; + cmykcolorhash[c][m][y][k] := _cmyk_counter_ ; + flush_special(1, 7, decimal _cmyk_counter_ & " " & s) ; + _local_specials_ := _local_specials_ & + " cmykcolorhash[" & decimal c & "][" & decimal m & + "][" & decimal y & "][" & decimal k & "] := -1 ; " ; + fi ; + (_special_signal_/1000,1/1000,cmykcolorhash[c][m][y][k]/1000) + else : + (1-c-k,1-m-k,1-y-k) + fi +enddef ; + +% newcolor truecyan, truemagenta, trueyellow ; +% +% truecyan = cmyk (1,0,0,0) ; +% truemagenta = cmyk (0,1,0,0) ; +% trueyellow = cmyk (0,0,1,0) ; + +%D Spot colors + +_spotcolor_counter_ := 0 ; +_spotcolor_number_ := 0 ; + +extra_endfig := " resetspotcolors ; " & extra_endfig ; + +def resetspotcolors = + numeric spotcolorhash[][] ; +enddef ; + +resetspotcolors ; boolean spotcolors ; spotcolors := false ; % true + +string spotcolorpattern[] ; % needed for transparancies + +vardef spotcolor(expr p, s) = + if spotcolors : + save ok, pc_tag ; boolean ok ; string pc_tag ; + pc_tag := "_pct_"&p ; + if not unstringed(pc_tag) : + _spotcolor_number_ := _spotcolor_number_ + 1 ; + setunstringed(pc_tag,_spotcolor_number_) ; + fi ; + pp := getunstringed(pc_tag) ; + if unknown spotcolorhash[pp][s] : + ok := false ; % not yet defined + elseif spotcolorhash[pp][s] = -1 : + ok := false ; % locally defined and undefined + else : + ok := true ; % globally already defined + fi ; + if not ok : + save ss ; string ss ; ss := p & " " & decimal s ; + _spotcolor_counter_ := _spotcolor_counter_ + 1 ; + spotcolorpattern[_spotcolor_counter_/1000] := ss ; + spotcolorhash[pp][s] := _spotcolor_counter_ ; + flush_special(2, 5, decimal _spotcolor_counter_ & " " & ss) ; + _local_specials_ := _local_specials_ & + "spotcolorhash["&decimal pp&"]["&decimal s&"]:=-1;" ; + fi ; + (_special_signal_/1000,2/1000,spotcolorhash[pp][s]/1000) + else : + (1-s,1-s,1-s) + fi +enddef ; + +%D Transparency + +normaltransparent := 1 ; multiplytransparent := 2 ; +screentransparent := 3 ; overlaytransparent := 4 ; +softlighttransparent := 5 ; hardlighttransparent := 6 ; +colordodgetransparent := 7 ; colorburntransparent := 8 ; +darkentransparent := 9 ; lightentransparent := 10 ; +differencetransparent := 11 ; exclusiontransparent := 12 ; + +% nottransparent := 0 ; +% compatibletransparent := 99 ; + +% fill fullcircle scaled 10cm withcolor transparant(.8,3,color) ; + +vardef transparent(expr n, t, c) = + save s, ss, nn, cc, is_cmyk, is_spot, ok ; + string s, ss ; numeric nn ; color cc ; boolean is_cmyk, is_spot, ok ; + % transparancy type + if string n : + if expandafter known scantokens(n&"transparent") : + nn := scantokens(n&"transparent") ; + else : + nn := 0 ; + fi + else : % nn := min(n,13) + nn := if n<13 : n else : nn := 0 fi ; + fi ; + % we need to expand the color (can be cmyk(..) or predefined) + cc := c ; % expand color + % check for cmyk special + is_cmyk := (redpart cc = _special_signal_/1000) + and (greenpart cc = 1/1000) ; + is_spot := (redpart cc = _special_signal_/1000) + and (greenpart cc = 2/1000) ; + % build special string, fetch cmyk components + s := decimal nn & " " & decimal t & " " & + if is_cmyk : cmykcolorpattern[bluepart cc] + elseif is_spot : spotcolorpattern[bluepart cc] + else : dddecimal cc fi ; + % check if this one is already used + ss := "tr_" & s ; + % efficiency hack + if expandafter unknown scantokens(ss) : + ok := false ; % not yet defined + elseif scantokens(ss) < 0 : + ok := false ; % locally defined and undefined + else : + ok := true ; % globally already defined + fi ; + if not ok : + if is_spot : + flush_special(5, 6, s) ; + elseif is_cmyk : + flush_special(4, 8, s) ; + else : + flush_special(3, 7, s) ; + fi ; + scantokens(ss) := _special_counter_ ; + _local_specials_ := _local_specials_ & + "scantokens(" & ditto & ss & ditto & ") := -1 ;" ; + fi ; + % go ahead + if is_spot : + (_special_signal_/1000,5/1000,scantokens(ss)/1000) + elseif is_cmyk : + (_special_signal_/1000,4/1000,scantokens(ss)/1000) + else : + (_special_signal_/1000,3/1000,scantokens(ss)/1000) + fi +enddef ; + +%D Basic position tracking: + +def register (expr label, width, height, offset) = + begingroup ; + flush_special(50, 7, + ddecimal offset & " " & + decimal width & " " & + decimal height & " " & label) ; + endgroup ; +enddef ; + +%D We cannot scale cmyk colors directly since this spoils +%D the trigger signal (such colors are no real colors). + +vardef scaledcmyk(expr c,m,y,k,sf) = + cmyk(sf*c,sf*m,sf*y,sf*k) +enddef ; + +vardef scaledcmykasrgb(expr c,m,y,k,sf) = + (sf*(1-c-k,1-m-k,1-y-k)) +enddef ; + +vardef scaledrgbascmyk(expr c,m,y,k,sf) = + scaledcmyk(1-c,1-m,1-y,0,sf) +enddef ; + +vardef scaledrgb(expr r,g,b,sf) = + (sf*(r,g,b)) +enddef ; + +vardef scaledgray(expr s,sf) = + (sf*(s,s,s)) +enddef ; + +% spotcolor is already scaled + +endinput ; diff --git a/metapost/context/base/mp-step.mp b/metapost/context/base/mp-step.mp new file mode 100644 index 000000000..d602f7014 --- /dev/null +++ b/metapost/context/base/mp-step.mp @@ -0,0 +1,320 @@ +%D \module +%D [ file=mp-step.mp, +%D version=2001.05.22, +%D title=\CONTEXT\ \METAPOST\ graphics, +%D subtitle=steps, +%D author=Hans Hagen, +%D date=\currentdate, +%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] +%C +%C This module is part of the \CONTEXT\ macro||package and is +%C therefore copyrighted by \PRAGMA. See licen-en.pdf for +%C details. + +if unknown context_tool : input mp-tool ; fi ; +if known context_step : endinput ; fi ; + +boolean context_step ; context_step := true ; + +%D In the associated \TEX\ module \type {m-steps}, we describe +%D three methods. The first method uses a different kind of +%D code than the other two. The method we decided to use, +%D is based on positional information (paths) provided by +%D \CONTEXT. + +def initialize_step_variables = + save line_method, line_h_offset, line_v_offset ; + numeric line_method ; line_method := 1 ; + numeric line_h_offset ; line_h_offset := 3pt ; + numeric line_v_offset ; line_v_offset := 3pt ; +enddef ; + +def begin_step_chart = + initialize_step_variables ; + save steps, texts, t, b, tb, nofcells ; + picture cells[][], texts[][][], lines[][][] ; + numeric t, b ; t := 1 ; b := 2 ; + numeric nofcells ; nofcells := 0 ; +enddef ; + +def analyze_step_chart = + numeric n[], l[][], r[][] ; pair p[] ; + n[t] := n[b] := 0 ; numeric tb ; + for i=1 upto nofcells : for nn = t, b : + if bbwidth(cells[nn][i])>0 : n[nn] := n[nn] + 1 ; fi ; + l[t][i] := r[t][i] := l[b][i] := r[b][i] := 0 ; + endfor ; endfor ; + % count left and right points + for i=1 upto nofcells-1 : for j=i upto nofcells-1 : for nn = t, b : + if bbwidth(texts[nn][i][j])>0 : + l[nn][i] := l[nn][i] + 1 ; + r[nn][j+1] := r[nn][j+1] + 1 ; + fi ; + endfor ; endfor ; endfor ; + % calculate left and right points + vardef do (expr nn, mm, ii, ss) = + if (l[nn][ii] + r[nn][ii]) > 1 : ss else : .5 fi + [ ulcorner cells[mm][ii], urcorner cells[mm][ii] ] + enddef ; + % combined rows + tb := if n[t]>0 : t else : b fi ; +enddef ; + +vardef get_step_chart_top_line (expr i, j) = + if bbwidth(cells[tb][i])>0 : + if bbwidth(texts[t][i][j])>0 : + if bbwidth(cells[tb][j+1])>0 : + p[1] := top do(t, tb, i, .6) ; + p[3] := top do(t, tb, j+1, .4) ; + p[2] := .5[p[1],p[3]] ; + if line_method = 1 : + p[2] := p[2] shifted (0, ypart + (llcorner texts[t][i][j] - ulcorner cells[tb][j+1])) ; + elseif line_method = 2 : + p[2] := center texts[t][i][j] ; + else : + % nothing + fi ; + p[1] := p[1] shifted (0,+line_v_offset) ; + p[2] := p[2] shifted (0,-line_v_offset) ; + p[3] := p[3] shifted (0,+line_v_offset) ; + (p[1] {up} ... p[2] ... {down} p[3]) + else : + origin + fi + else : + origin + fi + else : + origin + fi +enddef ; + +vardef get_step_chart_bot_line (expr i, j) = + if bbwidth(cells[b][i])>0 : + if bbwidth(texts[b][i][j])>0 : + if bbwidth(cells[b][j+1])>0 : + p[1] := (bot do(b, b, i, .6)) shifted (0,-bbheight(cells[b][i])) ; + p[3] := (bot do(b, b, j+1, .4)) shifted (0,-bbheight(cells[b][j+1])) ; + p[2] := .5[p[1],p[3]] ; + if line_method = 1 : + p[2] := p[2] shifted (0, -ypart + (llcorner cells[b][j+1] - ulcorner texts[b][i][j])) ; + elseif line_method = 2 : + p[2] := center texts[b][i][j] ; + fi ; + p[1] := p[1] shifted (0,-line_v_offset) ; + p[2] := p[2] shifted (0,+line_v_offset) ; + p[3] := p[3] shifted (0,-line_v_offset) ; + (p[1] {down} ... p[2] ... {up} p[3]) + else : + origin + fi + else : + origin + fi + else : + origin + fi +enddef ; + +def end_step_chart = + for i=1 upto nofcells : for nn = t, b : + if bbwidth(cells[nn][i]) >0 : draw cells[nn][i] ; fi ; + endfor ; endfor ; + for i=1 upto nofcells : for j=i upto nofcells : for nn = t, b : + if known lines[nn][i][j] : + if bbwidth(lines[nn][i][j])>0 : draw lines[nn][i][j] ; fi ; + fi ; + endfor ; endfor ; endfor ; + for i=1 upto nofcells : for j=i upto nofcells : for nn = t, b : + if bbwidth(texts[nn][i][j])>0 : draw texts[nn][i][j] ; fi ; + endfor ; endfor ; endfor ; +enddef ; + +%D Step tables. + +def begin_step_table = + initialize_step_variables ; + picture cells[], texts[], lines[] ; + numeric nofcells ; nofcells := 0 ; +enddef ; + +def end_step_table = + for i=1 upto nofcells : if known cells[i] : if bbwidth(cells[i])>0 : + draw cells[i] ; + fi ; fi ; endfor ; + for i=1 upto nofcells : if known lines[i] : if bbwidth(lines[i])>0 : + draw lines[i] ; + fi ; fi ; endfor ; + for i=1 upto nofcells : if known texts[i] : if bbwidth(texts[i])>0 : + draw texts[i] ; + fi ; fi ; endfor ; +enddef ; + +vardef get_step_table_line (expr i) = + pair prev, self, next ; + if known texts[i] : + self := lft .5[llcorner texts[i], ulcorner texts[i] ] ; + prev := rt if known texts[i-1] : .3 else : .5 fi [lrcorner cells[i] , urcorner cells[i] ] ; + next := rt if known texts[i+1] : .7 else : .5 fi [lrcorner cells[i+1], urcorner cells[i+1]] ; + self := self shifted (-line_h_offset,0) ; + prev := prev shifted (+line_h_offset,0) ; + next := next shifted (+line_h_offset,0) ; + prev {right} ... self ... {left} next + else : + origin + fi +enddef ; + +endinput + +%D The older method let \METAPOST\ do the typesetting. The +%D macros needed for that are included here for educational +%D purposes. +%D +%D \starttypen +%D def initialize_step_variables = +%D save line_color, line_width, arrow_alternative, +%D text_fill_color, text_line_color, text_line_width, text_offset, +%D cell_fill_color, cell_line_color, cell_line_width, cell_offset, +%D line_h_offset, line_v_offset ; +%D color line_color ; line_color := .4white ; +%D numeric line_width ; line_width := 1.5pt ; +%D color text_fill_color ; text_fill_color := white ; +%D color text_line_color ; text_line_color := red ; +%D numeric text_line_width ; text_line_width := 1pt ; +%D numeric text_offset ; text_offset := 2pt ; +%D color cell_fill_color ; cell_fill_color := white ; +%D color cell_line_color ; cell_line_color := blue ; +%D numeric cell_line_width ; cell_line_width := 1pt ; +%D numeric cell_offset ; cell_offset := 2pt ; +%D numeric line_alternative ; line_alternative := 1 ; +%D numeric line_h_offset ; line_h_offset := 3pt ; +%D numeric line_v_offset ; line_v_offset := 3pt ; +%D enddef ; +%D +%D def begin_step_chart = +%D begingroup ; +%D initialize_step_variables ; +%D save steps, texts, t, b ; +%D picture cells[][] ; numeric nofcells ; nofcells := 0 ; +%D picture texts[][][] ; numeric noftexts ; noftexts := 0 ; +%D numeric t, b ; t := 1 ; b := 2 ; +%D enddef ; +%D \stoptypen +%D +%D We use a couple of macros to store the content. In the +%D second (third) alternative we will directly fill the +%D cells. +%D +%D \starttypen +%D def set_step_chart_cells (expr one, two) = +%D nofcells := nofcells + 1 ; noftexts := 0 ; +%D cells[t][nofcells] := textext.rt(one) ; +%D cells[b][nofcells] := textext.rt(two) ; +%D enddef ; +%D +%D def set_step_chart_texts (expr one, two) = +%D noftexts := noftexts + 1 ; +%D texts[t][nofcells][noftexts] := textext.rt(one) ; +%D texts[b][nofcells][noftexts] := textext.rt(two) ; +%D enddef ; +%D \stoptypen +%D +%D If you compare the building macro with the later +%D alternative, you will notice that here we explicitly +%D have to calculate the distances and positions. +%D +%D \starttypen +%D def end_step_chart = +%D numeric dx ; dx := 0 ; path p ; +%D numeric n[] ; n[t] := n[b] := 0 ; +%D numeric stepsvdistance[] ; +%D vardef bbwidth (expr p) = (xpart (lrcorner p - llcorner p)) enddef ; +%D vardef bbheight (expr p) = (ypart (urcorner p - lrcorner p)) enddef ; +%D stepsvdistance[t] := stepsvdistance[b] := 0 ; +%D for i=1 upto nofcells : +%D % find largest bbox +%D p := boundingbox steps +%D [if bbwidth(cells[t][i])>bbwidth(cells[b][i]): t else: b fi][i] ; +%D % assign largest bbox +%D for nn = t, b : +%D if bbwidth(cells[nn][i])>0 : +%D setbounds cells[nn][i] to p enlarged cell_offset ; +%D n[nn] := n[nn] + 1 ; +%D fi ; +%D endfor ; +%D % determine height +%D if n[t]>0 : +%D stepsvdistance[t] := bbheight(cells[t][1]) + intertextdistance ; +%D fi ; +%D % add to row +%D for nn = t, b : +%D cells[nn][i] := cells[nn][i] shifted (dx,stepsvdistance[nn]) ; +%D if bbwidth(cells[nn][i])>0 : +%D dowithpath (boundingbox cells[nn][i], +%D cell_line_width, cell_line_color, cell_background_color) ; +%D fi ; +%D endfor ; +%D % calculate position +%D dx := dx + interstepdistance + bbwidth(cells[b][i]) ; +%D endfor ; +%D boolean stacked ; stacked := false ; +%D numeric l[][], r[][], l[][], r[][] ; +%D pair pa, pb, pc ; path p[] ; +%D for i=1 upto nofcells : +%D l[t][i] := r[t][i] := l[b][i] := r[b][i] := 0 ; +%D endfor ; +%D % count left and right points +%D for i=1 upto nofcells : for j=1 upto nofcells : for nn = t, b : +%D if known texts[nn][i][j] : if bbwidth(texts[nn][i][j])>0 : +%D l[nn][i] := l[nn][i] + 1 ; +%D r[nn][j+i] := r[nn][j+i] + 1 ; +%D stacked := (stacked or (j>1)) ; +%D setbounds texts[nn][i][j] to boundingbox texts[nn][i][j] enlarged cell_offset ; +%D fi fi ; +%D endfor ; endfor ; endfor ; +%D % calculate left and right points +%D vardef do (expr nn, mm, ii, ss) = +%D if (l[nn][ii] > 0) and (r[nn][ii] > 0) : ss else : .5 fi +%D [ ulcorner cells[mm][ii],urcorner cells[mm][ii] ] +%D enddef ; +%D % draw arrow from left to right point +%D def dodo (expr nn, ii, jj, dd) = +%D drawarrow p[nn] +%D withpen pencircle scaled arrow_line_width +%D withcolor arrow_line_color ; +%D transform tr ; tr := identity +%D shifted point .5 along p[nn] +%D shifted -center texts[nn][ii][jj] +%D if not stacked : shifted (0,dd) fi ; +%D dowithpath ((boundingbox texts[nn][ii][jj]) transformed tr, +%D text_line_width, text_line_color, text_fill_color) ; +%D enddef ; +%D % draw top and bottom text boxes +%D for i=1 upto nofcells : for j=1 upto nofcells : +%D pickup pencircle scaled arrow_line_width ; +%D if known texts[t][i][j] : if bbwidth(texts[t][i][j]) > 0 : +%D pa := top do(t, if n[t]>0 : t else : b fi, i, .6) ; +%D pb := top do(t, if n[t]>0 : t else : b fi, j+i, .4) ; +%D pc := .5[pa,pb] shifted (0,+step_arrow_depth) ; +%D p[t] := pa {up} .. if not stacked : pc .. fi {down} pb ; +%D dodo(t, i, j, +intertextdistance) ; +%D fi fi ; +%D if known texts[b][i][j] : if bbwidth(texts[b][i][j]) > 0 : +%D pa := (bot do(b, b, i, .6)) shifted (0,-bbheight(cells[b][i])) ; +%D pb := (bot do(b, b, j+i, .4)) shifted (0,-bbheight(cells[b][j+i])) ; +%D pc := .5[pa,pb] shifted (0,-step_arrow_depth) ; +%D p[b] := pa {down} .. if not stacked : pc .. fi {up} pb ; +%D dodo(b, i, j, -intertextdistance) ; +%D fi fi ; +%D endfor ; endfor ; +%D endgroup ; +%D enddef ; +%D \stoptypen +%D +%D If you compare both methods, you will notice that the +%D first method is the cleanest, but not the most efficient +%D (since it needs \TEX\ runs within \METAPOST\ runs within +%D \TEX\ runs). diff --git a/metapost/context/base/mp-symb.mp b/metapost/context/base/mp-symb.mp new file mode 100644 index 000000000..a84c84e82 --- /dev/null +++ b/metapost/context/base/mp-symb.mp @@ -0,0 +1,351 @@ +%D \module +%D [ file=mp-symb.mp, +%D version=very old, +%D title=\CONTEXT\ \METAPOST\ graphics, +%D subtitle=navigation symbol macros, +%D author=Hans Hagen, +%D date=\currentdate, +%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] +%C +%C This module is part of the \CONTEXT\ macro||package and is +%C therefore copyrighted by \PRAGMA. See mreadme.pdf for +%C details. + +%D Instead of these symbols, you can use the \type {contnav} +%D font by Taco Hoekwater that is derived form this file. + +u := 3; +h := 5u; +wt := 5u; +wb := .25wt; +o := .1u; +pw := .5u; + +drawoptions (withpen pencircle scaled pw); + +path lefttriangle, righttriangle, sublefttriangle, subrighttriangle; + +pair s ; s = (2wb,0) ; + +x1t = x2t = 0; +x3t = wt; +y3t = .5h; +z1t-z2t = (z3t-z2t) rotated 60; + +z4t = (z2t--z3t) intersectionpoint ((z1t--z2t) shifted s) ; +z5t = (z3t--z1t) intersectionpoint ((z1t--z2t) shifted s) ; + +righttriangle = z1t--z2t--z3t--cycle; +lefttriangle = righttriangle rotatedaround((0,.5h), 180) shifted (wt,0); + +subrighttriangle = z4t--((z2t--z3t--z1t) shifted s)--z5t ; +sublefttriangle = subrighttriangle rotatedaround((0,.5h), 180) shifted (wt,0); + +path sidebar; + +x1b = x4b = 0; +x2b = x3b = wb; +y1b = y2b = y1t; +y3b = y4b = y2t; + +sidebar = z1b--z2b--z3b--z4b--cycle; + +path midbar, onebar, twobar; + +hh = abs(y1t-y2t); + +%midbar := unitsquare scaled 2hh/3; +midbar := unitsquare scaled hh; +onebar := unitsquare xscaled (hh/3) yscaled hh; +twobar := onebar; + +def prepareglyph = + drawoptions (withpen pencircle scaled .5u); +enddef; + +def finishglyph = + set_outer_boundingbox currentpicture; + bboxmargin := o; + setbounds currentpicture to bbox currentpicture; +% draw boundingbox currentpicture withcolor red withpen pencircle scaled 1; +enddef; + +beginfig (1); + prepareglyph; + fill lefttriangle; + draw lefttriangle; % draw gets the bbox right, filldraw doesn't + finishglyph; +endfig; + +beginfig (2); + prepareglyph; + fill righttriangle; + draw righttriangle; + finishglyph; +endfig; + +beginfig (3); + prepareglyph; + fill sidebar; + draw sidebar; + fill lefttriangle shifted (.5s); + draw lefttriangle shifted (.5s); + finishglyph; +endfig; + +beginfig (4); + prepareglyph; + fill righttriangle; + draw righttriangle; + fill sidebar shifted (wt,0); + draw sidebar shifted (wt,0); + finishglyph; +endfig; + +beginfig (5); + prepareglyph; + fill lefttriangle; + draw lefttriangle; + fill lefttriangle shifted s; + draw lefttriangle shifted s; + finishglyph; +endfig; + +beginfig (6); + prepareglyph; + fill righttriangle; + draw righttriangle; + fill righttriangle shifted s; + draw righttriangle shifted s; + finishglyph; +endfig; + +beginfig (7); + prepareglyph; + fill midbar; + draw midbar; + finishglyph; +endfig; + +beginfig (8); + prepareglyph; + fill onebar; + draw onebar; + finishglyph; +endfig; + +beginfig (9); + prepareglyph; + fill twobar; + draw twobar; + fill twobar shifted (pw+hh/2,0); + draw twobar shifted (pw+hh/2,0); + finishglyph; +endfig; + +beginfig(101); + prepareglyph; + draw lefttriangle; + finishglyph; +endfig; + +beginfig(102); + prepareglyph; + draw righttriangle; + finishglyph; +endfig; + +beginfig(103); + prepareglyph; + draw sidebar; + draw lefttriangle shifted (.5s); + finishglyph; +endfig; + +beginfig(104); + prepareglyph; + draw righttriangle; + draw sidebar shifted (wt,0); + finishglyph; +endfig; + +beginfig(105); + prepareglyph; + draw lefttriangle; + draw lefttriangle shifted s; + finishglyph; +endfig; + +beginfig(106); + prepareglyph; + draw righttriangle; + draw righttriangle shifted s; + finishglyph; +endfig; + +beginfig(107); + prepareglyph; + draw midbar; + finishglyph; +endfig; + +beginfig(108); + prepareglyph; + draw onebar; + finishglyph; +endfig; + +beginfig(109); + prepareglyph; + draw twobar; + draw twobar shifted (pw+hh/2,0); + finishglyph; +endfig; + +beginfig(201); + prepareglyph; + draw lefttriangle; + finishglyph; +endfig; + +beginfig(202); + prepareglyph; + draw righttriangle; + finishglyph; +endfig; + +beginfig(203); + prepareglyph; + draw sidebar; + draw lefttriangle shifted (.5s); + finishglyph; +endfig; + +beginfig(204); + prepareglyph; + draw righttriangle; + draw sidebar shifted (wt,0); + finishglyph; +endfig; + +beginfig(205); + prepareglyph; + draw sublefttriangle shifted s; + draw lefttriangle shifted s; + finishglyph; +endfig; + +beginfig(206); + prepareglyph; + draw subrighttriangle; + draw righttriangle; + finishglyph; +endfig; + +beginfig(207); + prepareglyph; + draw midbar; + finishglyph; +endfig; + +beginfig(208); + prepareglyph; + draw onebar; + finishglyph; +endfig; + +beginfig(209); + prepareglyph; + draw twobar; + draw twobar shifted (pw+hh/2,0); + finishglyph; +endfig; + + +beginfig(999); + +picture collection [] ; + +prepareglyph ; +draw lefttriangle ; +finishglyph ; +collection[201] := currentpicture ; +currentpicture := nullpicture ; + +prepareglyph ; +draw righttriangle ; +finishglyph ; +collection[202] := currentpicture ; +currentpicture := nullpicture ; + +prepareglyph ; +draw sidebar ; +draw lefttriangle shifted (.5s) ; +finishglyph ; +collection[203] := currentpicture ; +currentpicture := nullpicture ; + +prepareglyph ; +draw righttriangle ; +draw sidebar shifted (wt,0) ; +finishglyph ; +collection[204] := currentpicture ; +currentpicture := nullpicture ; + +prepareglyph ; +draw sublefttriangle shifted s ; +draw lefttriangle shifted s ; +finishglyph ; +collection[205] := currentpicture ; +currentpicture := nullpicture ; + +prepareglyph ; +draw subrighttriangle ; +draw righttriangle ; +finishglyph ; +collection[206] := currentpicture ; +currentpicture := nullpicture ; + +prepareglyph ; +draw midbar ; +finishglyph ; +collection[207] := currentpicture ; +currentpicture := nullpicture ; + +prepareglyph ; +draw onebar ; +finishglyph ; +collection[208] := currentpicture ; +currentpicture := nullpicture ; + +prepareglyph ; +draw twobar ; +draw twobar shifted (pw+hh/2,0) ; +finishglyph ; +collection[209] := currentpicture ; +currentpicture := nullpicture ; + +for i=201 upto 209 : + collection[i] := collection[i] shifted - center collection[i] ; +endfor ; + +addto currentpicture also collection[205] shifted ( 0, 0) + withcolor (.3,.4,.5) ; +addto currentpicture also collection[202] shifted ( 0,1.5h) + withcolor (.5,.6,.7) ; +addto currentpicture also collection[201] shifted (1.5h, 0) + withcolor (.6,.7,.8) ; +addto currentpicture also collection[206] shifted (1.5h,1.5h) + withcolor (.4,.5,.6) ; + +collection[210] := currentpicture ; +currentpicture := nullpicture ; + +bboxmargin := .25u; + +fill bbox collection[210] withcolor .95(1,1,0); +addto currentpicture also collection[210] ; + +endfig ; + +end diff --git a/metapost/context/base/mp-text.mp b/metapost/context/base/mp-text.mp new file mode 100644 index 000000000..cb6bb3895 --- /dev/null +++ b/metapost/context/base/mp-text.mp @@ -0,0 +1,250 @@ +%D \module +%D [ file=mp-text.mp, +%D version=2000.07.10, +%D title=\CONTEXT\ \METAPOST\ graphics, +%D subtitle=text support, +%D author=Hans Hagen, +%D date=\currentdate, +%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] +%C +%C This module is part of the \CONTEXT\ macro||package and is +%C therefore copyrighted by \PRAGMA. See licen-en.pdf for +%C details. + +%D Under construction. + +if unknown context_tool : input mp-tool ; fi ; +if known context_text : endinput ; fi ; + +boolean context_text ; context_text := true ; + +if unknown noftexpictures : + numeric noftexpictures ; noftexpictures := 0 ; +fi ; + +if unknown texpictures[1] : + picture texpictures[] ; +fi ; + +numeric textextoffset ; textextoffset := 0 ; + +% vardef textext@#(expr txt) = +% interim labeloffset := textextoffset ; +% noftexpictures := noftexpictures + 1 ; +% if string txt : +% write "% figure " & decimal charcode & " : " & +% "texpictures[" & decimal noftexpictures & "] := btex " & +% txt & " etex ;" to jobname & ".mpt" ; +% if unknown texpictures[noftexpictures] : +% thelabel@#("unknown",origin) +% else : +% thelabel@#(texpictures[noftexpictures],origin) +% fi +% else : +% thelabel@#(txt,origin) +% fi +% enddef ; + +boolean hobbiestextext ; hobbiestextext := false ; + +vardef textext@#(expr txt) = + interim labeloffset := textextoffset ; + noftexpictures := noftexpictures + 1 ; + if string txt : + if hobbiestextext : % the tex.mp method as fallback (see tex.mp) + write "btex " & txt & " etex" to "mptextmp.mp" ; + write EOF to "mptextmp.mp" ; + scantokens "input mptextmp" + else : + write "% figure " & decimal charcode & " : " & + "texpictures[" & decimal noftexpictures & "] := btex " & + txt & " etex ;" to jobname & ".mpt" ; + if unknown texpictures[noftexpictures] : + thelabel@#("unknown",origin) + else : + thelabel@#(texpictures[noftexpictures],origin) + fi + fi + else : + thelabel@#(txt,origin) + fi +enddef ; + +string laboff_ ; laboff_ := "" ; +string laboff_c ; laboff_c := "" ; +string laboff_l ; laboff_l := ".lft" ; +string laboff_r ; laboff_r := ".rt" ; +string laboff_b ; laboff_b := ".bot" ; +string laboff_t ; laboff_t := ".top" ; +string laboff_lt ; laboff_lt := ".ulft" ; +string laboff_rt ; laboff_rt := ".urt" ; +string laboff_lb ; laboff_lb := ".llft" ; +string laboff_rb ; laboff_rb := ".lrt" ; +string laboff_tl ; laboff_tl := ".ulft" ; +string laboff_tr ; laboff_tr := ".urt" ; +string laboff_bl ; laboff_bl := ".llft" ; +string laboff_br ; laboff_br := ".lrt" ; + +vardef textextstr(expr s, a) = + save ss ; string ss ; + ss := "laboff_" & a ; + ss := scantokens ss ; + ss := "textext" & ss & "(" & ditto & s & ditto & ")" ; + scantokens ss +enddef ; + +pair laboff.origin ; laboff.origin = (infinity,infinity) ; +pair laboff.raw ; laboff.raw = (infinity,infinity) ; + +vardef thelabel@#(expr s, z) = + save p ; picture p ; + p = s if not picture s : infont defaultfont scaled defaultscale fi ; + if laboff@#<>laboff.origin : + (p shifted (z + labeloffset*laboff@# - (labxf@#*lrcorner p + + labyf@#*ulcorner p + (1-labxf@#-labyf@#)*llcorner p))) + else : + (p shifted z) + fi +enddef; + +def build_parshape (expr p, offset_or_path, dx, dy, + baselineskip, strutheight, strutdepth, topskip) = + + if unknown trace_parshape : + boolean trace_parshape ; trace_parshape := false ; + fi ; + + begingroup ; + + save q, l, r, line, tt, bb, + n, hsize, vsize, vvsize, voffset, hoffset, width, indent, + ll, lll, rr, rrr, cp, cq, t, b ; + + path q, l, r, line, tt, bb ; + numeric n, hsize, vsize, vvsize, voffset, hoffset, width[], indent[] ; + pair ll, lll, rr, rrr, cp, cq, t, b ; + + n := 0 ; cp := center p ; + + if path offset_or_path : + q := offset_or_path ; cq := center q ; + voffset := dy ; + hoffset := dx ; + else : + q := p ; cq := center q ; + hoffset := offset_or_path + dx ; + voffset := offset_or_path + dy ; + fi ; + + hsize := xpart lrcorner q - xpart llcorner q ; + vsize := ypart urcorner q - ypart lrcorner q ; + + q := p shifted - cp ; + + startsavingdata ; + + savedata "\global\parvoffset " & decimal voffset&"bp " ; + savedata "\global\parhoffset " & decimal hoffset&"bp " ; + savedata "\global\parwidth " & decimal hsize&"bp " ; + savedata "\global\parheight " & decimal vsize&"bp " ; + + if not path offset_or_path : + q := q xscaled ((hsize-2hoffset)/hsize) + yscaled ((vsize-2voffset)/vsize) ; + fi ; + + hsize := xpart lrcorner q - xpart llcorner q ; + vsize := ypart urcorner q - ypart lrcorner q ; + + t := (ulcorner q -- urcorner q) intersection_point q ; + b := (llcorner q -- lrcorner q) intersection_point q ; + + if xpart directionpoint t of q < 0 : + q := reverse q ; + fi ; + + l := q cutbefore t ; + l := l if xpart point 0 of q < 0 : & q fi cutafter b ; + + r := q cutbefore b ; + r := r if xpart point 0 of q > 0 : & q fi cutafter t ; + +% tt := (ulcorner q -- urcorner q) shifted (0,-topskip) ; +% bb := (llcorner q -- lrcorner q) shifted (0,strutdepth) ; +% +% l := l cutbefore (l intersection_point tt) ; +% l := l cutafter (l intersection_point bb) ; +% r := r cutbefore (r intersection_point bb) ; +% r := r cutafter (r intersection_point tt) ; + + if trace_parshape : + drawarrow p withpen pencircle scaled 2pt withcolor red ; + drawarrow l shifted cp withpen pencircle scaled 1pt withcolor green ; + drawarrow r shifted cp withpen pencircle scaled 1pt withcolor blue ; + fi ; + + vardef found_point (expr lin, pat, sig) = + pair a, b ; + a := pat intersection_point (lin shifted (0,strutheight)) ; + if intersection_found : + a := a shifted (0,-strutheight) ; + else : + a := pat intersection_point lin ; + fi ; + b := pat intersection_point (lin shifted (0,-strutdepth)) ; + if intersection_found : + if sig : + if xpart b > xpart a : a := b shifted (0,strutdepth) fi ; + else : + if xpart b < xpart a : a := b shifted (0,strutdepth) fi ; + fi ; + fi ; + a + enddef ; + + if (strutheight+strutdepth0) and (w>0) : scaled (w/bbwidth (p)) fi) +enddef ; + +primarydef p ysized h = + (p if (bbheight(p)>0) and (h>0) : scaled (h/bbheight(p)) fi) +enddef ; + +primarydef p xysized s = + begingroup ; + save wh, w, h ; pair wh ; numeric w, h ; + wh := paired (s) ; w := bbwidth(p) ; h := bbheight(p) ; + (p if (w>0) and (h>0) : + if xpart wh > 0 : xscaled (xpart wh/w) fi + if ypart wh > 0 : yscaled (ypart wh/h) fi + fi) + endgroup +enddef ; + +primarydef p sized wh = + (p xysized wh) +enddef ; + +def xscale_currentpicture(expr w) = + currentpicture := currentpicture xsized w ; +enddef; + +def yscale_currentpicture(expr h) = + currentpicture := currentpicture ysized h ; +enddef; + +def xyscale_currentpicture(expr w, h) = + currentpicture := currentpicture xysized (w,h) ; +enddef; + +def scale_currentpicture(expr w, h) = + currentpicture := currentpicture xsized w ; + currentpicture := currentpicture ysized h ; +enddef; + +%D A full circle is centered at the origin, while a unitsquare +%D is located in the first quadrant. Now guess what kind of +%D path fullsquare and unitcircle do return. + +path fullsquare, unitcircle ; + +fullsquare := unitsquare shifted - center unitsquare ; +unitcircle := fullcircle shifted urcorner fullcircle ; + +%D Some more paths: + +path urcircle, ulcircle, llcircle, lrcircle ; + +urcircle := origin--(+.5,0)&(+.5,0){up} ..(0,+.5)&(0,+.5)--cycle ; +ulcircle := origin--(0,+.5)&(0,+.5){left} ..(-.5,0)&(-.5,0)--cycle ; +llcircle := origin--(-.5,0)&(-.5,0){down} ..(0,-.5)&(0,-.5)--cycle ; +lrcircle := origin--(0,-.5)&(0,-.5){right}..(+.5,0)&(+.5,0)--cycle ; + +path tcircle, bcircle, lcircle, rcircle ; + +tcircle = origin--(+.5,0)&(+.5,0){up} ..(0,+.5)..{down} (-.5,0)--cycle ; +bcircle = origin--(-.5,0)&(-.5,0){down} ..(0,-.5)..{up} (+.5,0)--cycle ; +lcircle = origin--(0,+.5)&(0,+.5){left} ..(-.5,0)..{right}(0,-.5)--cycle ; +rcircle = origin--(0,-.5)&(0,-.5){right}..(+.5,0)..{left} (0,+.5)--cycle ; + +path urtriangle, ultriangle, lltriangle, lrtriangle ; + +urtriangle := origin--(+.5,0)--(0,+.5)--cycle ; +ultriangle := origin--(0,+.5)--(-.5,0)--cycle ; +lltriangle := origin--(-.5,0)--(0,-.5)--cycle ; +lrtriangle := origin--(0,-.5)--(+.5,0)--cycle ; + +path unitdiamond, fulldiamond ; + +unitdiamond := (.5,0)--(1,.5)--(.5,1)--(0,.5)--cycle ; +fulldiamond := unitdiamond shifted - center unitdiamond ; + +%D More robust: + +% let normalscaled = scaled ; +% let normalxscaled = xscaled ; +% let normalyscaled = yscaled ; +% +% def scaled expr s = normalscaled (s) enddef ; +% def xscaled expr s = normalxscaled (s) enddef ; +% def yscaled expr s = normalyscaled (s) enddef ; + +%D Shorter + +primarydef p xyscaled q = + begingroup ; save qq ; pair qq ; qq = paired(q) ; + ( p + if xpart qq<>0 : xscaled (xpart qq) fi + if ypart qq<>0 : yscaled (ypart qq) fi ) + endgroup +enddef ; + +%D Experimenteel, zie folder-3.tex. + +def set_grid(expr w, h, nx, ny) = + boolean grid[][] ; boolean grid_full ; + grid_w := w ; + grid_h := h ; + grid_nx := nx ; + grid_ny := ny ; + grid_x := round(w/grid_nx) ; % +.5) ; + grid_y := round(h/grid_ny) ; % +.5) ; + grid_left := (1+grid_x)*(1+grid_y) ; + grid_full := false ; + for i=0 upto grid_x: + for j=0 upto grid_y: + grid[i][j] := false ; + endfor ; + endfor ; +enddef ; + +vardef new_on_grid(expr _dx_, _dy_) = + dx := _dx_ ; + dy := _dy_ ; + ddx := min(round(dx/grid_nx),grid_x) ; % +.5),grid_x) ; + ddy := min(round(dy/grid_ny),grid_y) ; % +.5),grid_y) ; + if not grid_full and not grid[ddx][ddy]: + grid[ddx][ddy] := true ; + grid_left := grid_left-1 ; + grid_full := (grid_left=0) ; + true + else: + false + fi +enddef ; + +%D usage: \type{innerpath peepholed outerpath}. +%D +%D beginfig(1); +%D def fullsquare = (unitsquare shifted -center unitsquare) enddef ; +%D fill (fullsquare scaled 200) withcolor red ; +%D path p ; p := (fullcircle scaled 100) ; bboxmargin := 0 ; +%D fill p peepholed bbox p ; +%D endfig; + +secondarydef p peepholed q = + begingroup ; + save start ; pair start ; start := point 0 of p ; + if xpart start >= xpart center p : + if ypart start >= ypart center p : + urcorner q -- ulcorner q -- llcorner q -- lrcorner q -- + reverse p -- lrcorner q -- cycle + else : + lrcorner q -- urcorner q -- ulcorner q -- llcorner q -- + reverse p -- llcorner q -- cycle + fi + else : + if ypart start > ypart center p : + ulcorner q -- llcorner q -- lrcorner q -- urcorner q -- + reverse p -- urcorner q -- cycle + else : + llcorner q -- lrcorner q -- urcorner q -- ulcorner q -- + reverse p -- ulcorner q -- cycle + fi + fi + endgroup +enddef ; + +boolean intersection_found ; + +secondarydef p intersection_point q = + begingroup + save x_, y_ ; + (x_,y_) = p intersectiontimes q ; + if x_<0 : + intersection_found := false ; + center p % origin + else : + intersection_found := true ; + .5[point x_ of p, point y_ of q] + fi + endgroup +enddef ; + +%D New, undocumented, experimental: + +vardef tensecircle (expr width, height, offset) = + ((-width/2,-height/2) ... (0,-height/2-offset) ... + (+width/2,-height/2) ... (+width/2+offset,0) ... + (+width/2,+height/2) ... (0,+height/2+offset) ... + (-width/2,+height/2) ... (-width/2-offset,0) ... cycle) +enddef ; + +%vardef tensecircle (expr width, height, offset) = +% ((-width/2,-height/2)..(0,-height/2-offset)..(+width/2,-height/2) & +% (+width/2,-height/2)..(+width/2+offset,0)..(+width/2,+height/2) & +% (+width/2,+height/2)..(0,+height/2+offset)..(-width/2,+height/2) & +% (-width/2,+height/2)..(-width/2-offset,0)..(-width/2,-height/2)..cycle) +%enddef ; + +vardef roundedsquare (expr width, height, offset) = + ((offset,0)--(width-offset,0){right} .. + (width,offset)--(width,height-offset){up} .. + (width-offset,height)--(offset,height){left} .. + (0,height-offset)--(0,offset){down} .. cycle) +enddef ; + +%D Some colors. + +color cyan ; cyan = (0,1,1) ; +color magenta ; magenta = (1,0,1) ; +color yellow ; yellow = (1,1,0) ; + +%D Well, this is the dangerous and naive version: + +def drawfill text t = + fill t ; + draw t ; +enddef; + +%D This two step approach saves the path first, since it can +%D be a function. Attributes must not be randomized. + +def drawfill expr c = + path _c_ ; _c_ := c ; + do_drawfill +enddef ; + +def do_drawfill text t = + draw _c_ t ; + fill _c_ t ; +enddef; + +def undrawfill expr c = + drawfill c withcolor background +enddef ; + +%D Moved from mp-char.mp + +vardef paired (expr d) = + if pair d : d else : (d,d) fi +enddef ; + +vardef tripled (expr d) = + if color d : d else : (d,d,d) fi +enddef ; + +primarydef p enlarged d = + (p llmoved d -- p lrmoved d -- p urmoved d -- p ulmoved d -- cycle) +enddef; + +primarydef p llenlarged d = + (p llmoved d -- lrcorner p -- urcorner p -- ulcorner p -- cycle) +enddef ; + +primarydef p lrenlarged d = + (llcorner p -- p lrmoved d -- urcorner p -- ulcorner p -- cycle) +enddef ; + +primarydef p urenlarged d = + (llcorner p -- lrcorner p -- p urmoved d -- ulcorner p -- cycle) +enddef ; + +primarydef p ulenlarged d = + (llcorner p -- lrcorner p -- urcorner p -- p ulmoved d -- cycle) +enddef ; + +primarydef p llmoved d = + ((llcorner p) shifted (-xpart paired(d),-ypart paired(d))) +enddef ; + +primarydef p lrmoved d = + ((lrcorner p) shifted (+xpart paired(d),-ypart paired(d))) +enddef ; + +primarydef p urmoved d = + ((urcorner p) shifted (+xpart paired(d),+ypart paired(d))) +enddef ; + +primarydef p ulmoved d = + ((ulcorner p) shifted (-xpart paired(d),+ypart paired(d))) +enddef ; + +primarydef p leftenlarged d = + ((llcorner p) shifted (-d,0) -- lrcorner p -- + urcorner p -- (ulcorner p) shifted (-d,0) -- cycle) +enddef ; + +primarydef p rightenlarged d = + (llcorner p -- (lrcorner p) shifted (d,0) -- + (urcorner p) shifted (d,0) -- ulcorner p -- cycle) +enddef ; + +primarydef p topenlarged d = + (llcorner p -- lrcorner p -- + (urcorner p) shifted (0,d) -- (ulcorner p) shifted (0,d) -- cycle) +enddef ; + +primarydef p bottomenlarged d = + (llcorner p shifted (0,-d) -- lrcorner p shifted (0,-d) -- + urcorner p -- ulcorner p -- cycle) +enddef ; + +%D Saves typing: + +% vardef bottomboundary primary p = (llcorner p -- lrcorner p) enddef ; +% vardef rightboundary primary p = (lrcorner p -- urcorner p) enddef ; +% vardef topboundary primary p = (urcorner p -- ulcorner p) enddef ; +% vardef leftboundary primary p = (ulcorner p -- llcorner p) enddef ; + +vardef bottomboundary primary p = + if pair p : p else : (llcorner p -- lrcorner p) fi +enddef ; + +vardef rightboundary primary p = + if pair p : p else : (lrcorner p -- urcorner p) fi +enddef ; + +vardef topboundary primary p = + if pair p : p else : (urcorner p -- ulcorner p) fi +enddef ; + +vardef leftboundary primary p = + if pair p : p else : (ulcorner p -- llcorner p) fi +enddef ; + +%D Nice too: + +primarydef p superellipsed s = + superellipse + (.5[lrcorner p,urcorner p], + .5[urcorner p,ulcorner p], + .5[ulcorner p,llcorner p], + .5[llcorner p,lrcorner p], + s) +enddef ; + +primarydef p squeezed s = + ((llcorner p .. .5[llcorner p,lrcorner p] shifted ( 0, ypart paired(s)) .. lrcorner p) & + (lrcorner p .. .5[lrcorner p,urcorner p] shifted (-xpart paired(s), 0) .. urcorner p) & + (urcorner p .. .5[urcorner p,ulcorner p] shifted ( 0,-ypart paired(s)) .. ulcorner p) & + (ulcorner p .. .5[ulcorner p,llcorner p] shifted ( xpart paired(s), 0) .. llcorner p) & cycle) +enddef ; + +primarydef p randomshifted s = + begingroup ; save ss ; pair ss ; ss := paired(s) ; + p shifted (-.5xpart ss + uniformdeviate xpart ss, + -.5ypart ss + uniformdeviate ypart ss) + endgroup +enddef ; + +%primarydef p randomized s = +% for i=0 upto length(p)-1 : +% ((point i of p) randomshifted s) .. controls +% ((postcontrol i of p) randomshifted s) and +% ((precontrol (i+1) of p) randomshifted s) .. +% endfor cycle +%enddef ; + +primarydef p randomized s = + (if path p : + for i=0 upto length(p)-1 : + ((point i of p) randomshifted s) .. controls + ((postcontrol i of p) randomshifted s) and + ((precontrol (i+1) of p) randomshifted s) .. + endfor + if cycle p : + cycle + else : + ((point length(p) of p) randomshifted s) + fi + elseif pair p : + p randomshifted s + elseif color p : + if color s : + (uniformdeviate redpart s * redpart p, + uniformdeviate greenpart s * greenpart p, + uniformdeviate bluepart s * bluepart p) + elseif pair s : + ((xpart s + uniformdeviate (ypart s - xpart s)) * p) + else : + (uniformdeviate s * p) + fi + else : + p + uniformdeviate s + fi) +enddef ; + +%D Not perfect (alternative for interpath) + +vardef interpolated(expr s, p, q) = + save m ; m := max(length(p),length(q)) ; + (if path p : + for i=0 upto m-1 : + s[point (i /m) along p, + point (i /m) along q] .. controls + s[postcontrol (i /m) along p, + postcontrol (i /m) along q] and + s[precontrol ((i+1)/m) along p, + precontrol ((i+1)/m) along q] .. + endfor + if cycle p : + cycle + else : + s[point infinity of p, + point infinity of q] + fi + else : + a[p,q] + fi) +enddef ; + +%D Interesting too: + +% primarydef p parallel s = +% begingroup ; save q, b ; path q ; numeric b ; +% b := xpart (lrcorner p - llcorner p) ; +% q := p if b>0 : scaled ((b+2s)/b) fi ; +% (q shifted (center p-center q)) +% endgroup +% enddef ; + +%primarydef p parallel s = +% begingroup ; save q, w,h ; path q ; numeric w, h ; +% w := bbwidth(p) ; h := bbheight(p) ; +% q := p if (w>0) and (h>0) : +% xyscaled ((w+2*xpart paired(s))/w,(h+2*ypart paired(s))/h) fi ; +% (q shifted (center p-center q)) +% endgroup +%enddef ; + +vardef punked primary p = + (point 0 of p for i=1 upto length(p)-1 : -- point i of p endfor + if cycle p : -- cycle else : -- point length(p) of p fi) +enddef ; + +vardef curved primary p = + (point 0 of p for i=1 upto length(p)-1 : .. point i of p endfor + if cycle p : .. cycle else : .. point length(p) of p fi) +enddef ; + +primarydef p blownup s = + begingroup + save _p_ ; path _p_ ; _p_ := p xysized + (bbwidth (p)+2(xpart paired(s)), + bbheight(p)+2(ypart paired(s))) ; + (_p_ shifted (center p - center _p_)) + endgroup +enddef ; + +%D Rather fundamental. + +% vardef rightpath expr p = +% save q, t, b ; path q ; pair t, b ; +% t := (ulcorner p -- urcorner p) intersection_point p ; +% b := (llcorner p -- lrcorner p) intersection_point p ; +% if xpart directionpoint t of p < 0 : p := reverse p ; fi ; +% q := p cutbefore b ; +% q := q if xpart point 0 of p > 0 : & p fi cutafter t ; +% q +% enddef ; +% +% vardef leftpath expr p = +% save q, t, b ; path q ; pair t, b ; +% t := (ulcorner p -- urcorner p) intersection_point p ; +% b := (llcorner p -- lrcorner p) intersection_point p ; +% if xpart directionpoint t of p < 0 : p := reverse p ; fi ; +% q := p cutbefore t ; +% q := q if xpart point 0 of p > 0 : & p fi cutafter b ; +% q +% enddef ; + +def leftrightpath(expr p, l) = + save q, t, b ; path q ; pair t, b ; + t := (ulcorner p -- urcorner p) intersection_point p ; + b := (llcorner p -- lrcorner p) intersection_point p ; + if xpart directionpoint t of p < 0 : p := reverse p ; fi ; + q := p cutbefore if l: t else: b fi ; + q := q if xpart point 0 of p > 0 : & + p fi cutafter if l: b else: t fi ; + q +enddef ; + +vardef leftpath expr p = leftrightpath(p,true ) enddef ; +vardef rightpath expr p = leftrightpath(p,false) enddef ; + +%D Drawoptions + +def saveoptions = + save _op_ ; def _op_ = enddef ; +enddef ; + +%D Tracing. + +let normaldraw = draw ; +let normalfill = fill ; + +def drawlineoptions (text t) = def _lin_opt_ = t enddef ; enddef ; +def drawpointoptions (text t) = def _pnt_opt_ = t enddef ; enddef ; +def drawcontroloptions(text t) = def _ctr_opt_ = t enddef ; enddef ; +def drawlabeloptions (text t) = def _lab_opt_ = t enddef ; enddef ; +def draworiginoptions (text t) = def _ori_opt_ = t enddef ; enddef ; +def drawboundoptions (text t) = def _bnd_opt_ = t enddef ; enddef ; +def drawpathoptions (text t) = def _pth_opt_ = t enddef ; enddef ; + +def resetdrawoptions = + drawlineoptions (withpen pencircle scaled 1pt withcolor .5white) ; + drawpointoptions (withpen pencircle scaled 4pt withcolor black) ; + drawcontroloptions(withpen pencircle scaled 2.5pt withcolor black) ; + drawlabeloptions () ; + draworiginoptions (withpen pencircle scaled 1pt withcolor .5white) ; + drawboundoptions (dashed evenly _ori_opt_) ; + drawpathoptions (withpen pencircle scaled 5pt withcolor .8white) ; +enddef ; + +resetdrawoptions ; + +%D Path. + +def drawpath expr p = + normaldraw p _pth_opt_ +enddef ; + +%D Arrow. + +vardef drawarrowpath expr p = + save autoarrows ; boolean autoarrows ; autoarrows := true ; + drawarrow p _pth_opt_ +enddef ; + +%def drawarrowpath expr p = +% begingroup ; +% save autoarrows ; boolean autoarrows ; autoarrows := true ; +% save arrowpath ; path arrowpath ; arrowpath := p ; +% _drawarrowpath_ +%enddef ; +% +%def _drawarrowpath_ text t = +% drawarrow arrowpath _pth_opt_ t ; +% endgroup ; +%enddef ; + +def midarrowhead expr p = + arrowhead p cutafter + (point length(p cutafter point .5 along p)+ahlength on p) +enddef ; + +vardef arrowheadonpath (expr p, s) = + save autoarrows ; boolean autoarrows ; autoarrows := true ; + arrowhead p if s<1 : cutafter (point (s*arclength(p)+.5ahlength) on p) fi +enddef ; + +%D Points. + +def drawpoint expr c = + if string c : + string _c_ ; _c_ := "(" & c & ")" ; + dotlabel.urt(_c_, scantokens _c_) ; + drawdot scantokens _c_ + else : + dotlabel.urt("(" & decimal xpart c & "," & decimal ypart c & ")", c) ; + drawdot c + fi _pnt_opt_ +enddef ; + +%D PathPoints. + +def drawpoints expr c = path _c_ ; _c_ := c ; do_drawpoints enddef ; +def drawcontrolpoints expr c = path _c_ ; _c_ := c ; do_drawcontrolpoints enddef ; +def drawcontrollines expr c = path _c_ ; _c_ := c ; do_drawcontrollines enddef ; +def drawpointlabels expr c = path _c_ ; _c_ := c ; do_drawpointlabels enddef ; + +def do_drawpoints text t = + for _i_=0 upto length(_c_) : + normaldraw point _i_ of _c_ _pnt_opt_ t ; + endfor ; +enddef; + +def do_drawcontrolpoints text t = + for _i_=0 upto length(_c_) : + normaldraw precontrol _i_ of _c_ _ctr_opt_ t ; + normaldraw postcontrol _i_ of _c_ _ctr_opt_ t ; + endfor ; +enddef; + +def do_drawcontrollines text t = + for _i_=0 upto length(_c_) : + normaldraw point _i_ of _c_ -- precontrol _i_ of _c_ _lin_opt_ t ; + normaldraw point _i_ of _c_ -- postcontrol _i_ of _c_ _lin_opt_ t ; + endfor ; +enddef; + +boolean swappointlabels ; swappointlabels := false ; + +def do_drawpointlabels text t = + for _i_=0 upto length(_c_) : + pair _u_ ; _u_ := unitvector(direction _i_ of _c_) + rotated if swappointlabels : - fi 90 ; + pair _p_ ; _p_ := (point _i_ of _c_) ; + _u_ := 12 * defaultscale * _u_ ; + normaldraw thelabel ( decimal _i_, + _p_ shifted if cycle _c_ and (_i_=0) : - fi _u_ ) _lab_opt_ t ; + endfor ; +enddef; + +%D Bounding box. + +def drawboundingbox expr p = + normaldraw boundingbox p _bnd_opt_ +enddef ; + +%D Origin. + +numeric originlength ; originlength := .5cm ; + +def draworigin text t = + normaldraw (origin shifted (0, originlength) -- + origin shifted (0,-originlength)) _ori_opt_ t ; + normaldraw (origin shifted ( originlength,0) -- + origin shifted (-originlength,0)) _ori_opt_ t ; +enddef; + +%D Axis. + +numeric tickstep ; tickstep := 5mm ; +numeric ticklength ; ticklength := 2mm ; + +def drawxticks expr c = path _c_ ; _c_ := c ; do_drawxticks enddef ; +def drawyticks expr c = path _c_ ; _c_ := c ; do_drawyticks enddef ; +def drawticks expr c = path _c_ ; _c_ := c ; do_drawticks enddef ; + +% Adding eps prevents disappearance due to rounding errors. + +def do_drawxticks text t = + for i=0 step -tickstep until xpart llcorner _c_ - eps : + if (i<=xpart lrcorner _c_) : + normaldraw (i,-ticklength)--(i,ticklength) _ori_opt_ t ; + fi ; + endfor ; + for i=0 step tickstep until xpart lrcorner _c_ + eps : + if (i>=xpart llcorner _c_) : + normaldraw (i,-ticklength)--(i,ticklength) _ori_opt_ t ; + fi ; + endfor ; + normaldraw (llcorner _c_ -- ulcorner _c_) + shifted (-xpart llcorner _c_,0) _ori_opt_ t ; +enddef ; + +def do_drawyticks text t = + for i=0 step -tickstep until ypart llcorner _c_ - eps : + if (i<=ypart ulcorner _c_) : + normaldraw (-ticklength,i)--(ticklength,i) _ori_opt_ t ; + fi ; + endfor ; + for i=0 step tickstep until ypart ulcorner _c_ + eps : + if (i>=ypart llcorner _c_) : + normaldraw (-ticklength,i)--(ticklength,i) _ori_opt_ t ; + fi ; + endfor ; + normaldraw (llcorner _c_ -- lrcorner _c_) + shifted (0,-ypart llcorner _c_) _ori_opt_ t ; +enddef ; + +def do_drawticks text t = + drawxticks _c_ t ; + drawyticks _c_ t ; +enddef ; + +%D All of it except axis. + +def drawwholepath expr p = + draworigin ; + drawpath p ; + drawcontrollines p ; + drawcontrolpoints p ; + drawpoints p ; + drawboundingbox p ; + drawpointlabels p ; +enddef ; + +%D Tracing. + +def visualizeddraw expr c = + if picture c : normaldraw c else : path _c_ ; _c_ := c ; do_visualizeddraw fi +enddef ; + +def visualizedfill expr c = + if picture c : normalfill c else : path _c_ ; _c_ := c ; do_visualizedfill fi +enddef ; + +def do_visualizeddraw text t = + draworigin ; + drawpath _c_ t ; + drawcontrollines _c_ ; + drawcontrolpoints _c_ ; + drawpoints _c_ ; + drawboundingbox _c_ ; + drawpointlabels _c_ ; +enddef ; + +def do_visualizedfill text t = + if cycle _c_ : normalfill _c_ t fi ; + draworigin ; + drawcontrollines _c_ ; + drawcontrolpoints _c_ ; + drawpoints _c_ ; + drawboundingbox _c_ ; + drawpointlabels _c_ ; +enddef ; + +def visualizepaths = + let fill = visualizedfill ; + let draw = visualizeddraw ; +enddef ; + +def naturalizepaths = + let fill = normalfill ; + let draw = normaldraw ; +enddef ; + +extra_endfig := extra_endfig & " naturalizepaths ; " ; + +%D Normally, arrowheads don't scale well. So we provide a +%D hack. + +boolean autoarrows ; autoarrows := false ; +numeric ahfactor ; ahfactor := 2.5 ; + +def set_ahlength (text t) = + ahlength := (ahfactor*pen_size(_op_ t)) ; % _op_ added +enddef ; + +vardef pen_size (text t) = + save p ; picture p ; p := nullpicture ; + addto p doublepath (top origin -- bot origin) t ; + (ypart urcorner p - ypart lrcorner p) +enddef ; + +%D The next two macros are adapted versions of plain +%D \METAPOST\ definitions. + +def _finarr text t = + if autoarrows : set_ahlength (t) fi ; + draw _apth t ; + filldraw arrowhead _apth t ; +enddef; + +def _findarr text t = + if autoarrows : set_ahlength (t) fi ; + draw _apth t ; + fill arrowhead _apth withpen currentpen t ; + fill arrowhead reverse _apth withpen currentpen t ; +enddef ; + +%D Handy too ...... + +vardef pointarrow (expr pat, loc, len, off) = + save l, r, s, t ; path l, r ; numeric s ; pair t ; + t := if pair loc : loc else : point loc along pat fi ; +% draw t withpen pencircle scaled 10 withcolor .5white ; + s := len/2 - off ; if s<=0 : s := 0 elseif s>len : s := len fi ; + r := pat cutbefore t ; + r := (r cutafter point (arctime s of r) of r) ; + s := len/2 + off ; if s<=0 : s := 0 elseif s>len : s := len fi ; + l := reverse (pat cutafter t) ; + l := (reverse (l cutafter point (arctime s of l) of l)) ; + (l..r) +enddef ; + +def rightarrow (expr pat,tim,len) = pointarrow(pat,tim,len,-len) enddef ; +def leftarrow (expr pat,tim,len) = pointarrow(pat,tim,len,+len) enddef ; +def centerarrow (expr pat,tim,len) = pointarrow(pat,tim,len, 0) enddef ; + +%D The \type {along} and \type {on} operators can be used +%D as follows: +%D +%D \starttypen +%D drawdot point .5 along somepath ; +%D drawdot point 3cm on somepath ; +%D \stoptypen +%D +%D The number denotes a percentage (fraction). + +primarydef pct along pat = % also negative + (arctime (pct * (arclength pat)) of pat) of pat +enddef ; + +% primarydef len on pat = +% (arctime len of pat) of pat +% enddef ; + +primarydef len on pat = + (arctime if len>0 : len else : (arclength(pat)+len) fi of pat) of pat +enddef ; + +% this cuts of a piece from both ends + +% tertiarydef pat cutends len = +% begingroup ; save tap ; path tap ; +% tap := pat cutbefore (point len on pat) ; +% (tap cutafter (point -len on tap)) +% endgroup +% enddef ; + +tertiarydef pat cutends len = + begingroup ; save tap ; path tap ; + tap := pat cutbefore (point (xpart paired(len)) on pat) ; + (tap cutafter (point -(ypart paired(len)) on tap)) + endgroup +enddef ; + +%D To be documented. + +path freesquare ; + +freesquare := ((-1,0)--(-1,-1)--(0,-1)--(+1,-1)-- + (+1,0)--(+1,+1)--(0,+1)--(-1,+1)--cycle) scaled .5 ; + +numeric freelabeloffset ; freelabeloffset := 3pt ; +numeric freedotlabelsize ; freedotlabelsize := 3pt ; + +vardef thefreelabel (expr str, loc, ori) = + save s, p, q, l ; picture s ; path p, q ; pair l ; + interim labeloffset := freelabeloffset ; + s := if string str : thelabel(str,loc) else : str shifted -center str shifted loc fi ; + setbounds s to boundingbox s enlarged freelabeloffset ; + p := fullcircle scaled (2*length(loc-ori)) shifted ori ; + q := freesquare xyscaled (urcorner s - llcorner s) ; +% l := point (xpart (p intersectiontimes (ori--loc))) of q ; + l := point xpart (p intersectiontimes + (ori--((1+eps)*arclength(ori--loc)*unitvector(loc-ori)))) of q ; + setbounds s to boundingbox s enlarged -freelabeloffset ; % new + %draw boundingbox s shifted -l withpen pencircle scaled .5pt withcolor red ; + (s shifted -l) +enddef ; + +% better? + +vardef thefreelabel (expr str, loc, ori) = + save s, p, q, l ; picture s ; path p, q ; pair l ; + interim labeloffset := freelabeloffset ; + s := if string str : thelabel(str,loc) else : str shifted -center str shifted loc fi ; + setbounds s to boundingbox s enlarged freelabeloffset ; + p := fullcircle scaled (2*length(loc-ori)) shifted ori ; + q := freesquare xyscaled (urcorner s - llcorner s) ; + l := point xpart (p intersectiontimes (ori--loc shifted (loc-ori))) of q ; + setbounds s to boundingbox s enlarged -freelabeloffset ; % new + %draw boundingbox s shifted -l withpen pencircle scaled .5pt withcolor red ; + (s shifted -l) +enddef ; + +vardef freelabel (expr str, loc, ori) = + draw thefreelabel(str,loc,ori) ; +enddef ; + +vardef freedotlabel (expr str, loc, ori) = + interim linecap:=rounded ; + draw loc withpen pencircle scaled freedotlabelsize ; + draw thefreelabel(str,loc,ori) ; +enddef ; + +%D \starttypen +%D drawarrow anglebetween(line_a,line_b,somelabel) ; +%D \stoptypen + +% angleoffset ; angleoffset := 0pt ; +numeric anglelength ; anglelength := 20pt ; +numeric anglemethod ; anglemethod := 1 ; + +% vardef anglebetween (expr a, b, str) = % path path string +% save pointa, pointb, common, middle, offset ; +% pair pointa, pointb, common, middle, offset ; +% save curve ; path curve ; +% save where ; numeric where ; +% if round point 0 of a = round point 0 of b : +% common := point 0 of a ; +% else : +% common := a intersectionpoint b ; +% fi ; +% pointa := point anglelength on a ; +% pointb := point anglelength on b ; +% where := turningnumber (common--pointa--pointb--cycle) ; +% middle := ((common--pointa) rotatedaround (pointa,-where*90)) +% intersectionpoint +% ((common--pointb) rotatedaround (pointb, where*90)) ; +% if anglemethod = 0 : +% curve := pointa{unitvector(middle-pointa)}.. pointb; +% middle := point .5 along curve ; +% curve := common ; +% elseif anglemethod = 1 : +% curve := pointa{unitvector(middle-pointa)}.. pointb; +% middle := point .5 along curve ; +% elseif anglemethod = 2 : +% middle := common rotatedaround(.5[pointa,pointb],180) ; +% curve := pointa--middle--pointb ; +% elseif anglemethod = 3 : +% curve := pointa--middle--pointb ; +% elseif anglemethod = 4 : +% curve := pointa..controls middle..pointb ; +% middle := point .5 along curve ; +% fi ; +% draw thefreelabel(str, middle, common) withcolor black ; +% curve +% enddef ; + +vardef anglebetween (expr a, b, str) = % path path string + save pointa, pointb, common, middle, offset ; + pair pointa, pointb, common, middle, offset ; + save curve ; path curve ; + save where ; numeric where ; + if round point 0 of a = round point 0 of b : + common := point 0 of a ; + else : + common := a intersectionpoint b ; + fi ; + pointa := point anglelength on a ; + pointb := point anglelength on b ; + where := turningnumber (common--pointa--pointb--cycle) ; + middle := (reverse(common--pointa) rotatedaround (pointa,-where*90)) + intersection_point + (reverse(common--pointb) rotatedaround (pointb, where*90)) ; + if not intersection_found : + middle := point .5 along + ((reverse(common--pointa) rotatedaround (pointa,-where*90)) -- + ( (common--pointb) rotatedaround (pointb, where*90))) ; + fi ; + if anglemethod = 0 : + curve := pointa{unitvector(middle-pointa)}.. pointb; + middle := point .5 along curve ; + curve := common ; + elseif anglemethod = 1 : + curve := pointa{unitvector(middle-pointa)}.. pointb; + middle := point .5 along curve ; + elseif anglemethod = 2 : + middle := common rotatedaround(.5[pointa,pointb],180) ; + curve := pointa--middle--pointb ; + elseif anglemethod = 3 : + curve := pointa--middle--pointb ; + elseif anglemethod = 4 : + curve := pointa..controls middle..pointb ; + middle := point .5 along curve ; + fi ; + draw thefreelabel(str, middle, common) ; % withcolor black ; + curve +enddef ; + +% Stack + +picture currentpicturestack[] ; +numeric currentpicturedepth ; currentpicturedepth := 0 ; + +def pushcurrentpicture = + currentpicturedepth := currentpicturedepth + 1 ; + currentpicturestack[currentpicturedepth] := currentpicture ; + currentpicture := nullpicture ; +enddef ; + +def popcurrentpicture text t = % optional text + if currentpicturedepth > 0 : + addto currentpicturestack[currentpicturedepth] also currentpicture t ; + currentpicture := currentpicturestack[currentpicturedepth] ; + currentpicturedepth := currentpicturedepth - 1 ; + fi ; +enddef ; + +%D colorcircle(size, red, green, blue) ; + +% vardef colorcircle (expr size, red, green, blue) = +% save r, g, b, rr, gg, bb, cc, mm, yy ; save radius ; +% path r, g, b, rr, bb, gg, cc, mm, yy ; numeric radius ; +% +% radius := 5cm ; pickup pencircle scaled (radius/25) ; +% +% r := g := b := fullcircle scaled radius shifted (0,radius/4) ; +% +% r := r rotatedaround (origin, 15) ; +% g := g rotatedaround (origin,135) ; +% b := b rotatedaround (origin,255) ; +% +% r := r rotatedaround(center r,-90) ; +% g := g rotatedaround(center g, 90) ; +% +% gg := buildcycle(buildcycle(reverse r,b),g) ; +% cc := buildcycle(buildcycle(b,reverse g),r) ; +% +% rr := gg rotatedaround(origin,120) ; +% bb := gg rotatedaround(origin,240) ; +% +% yy := cc rotatedaround(origin,120) ; +% mm := cc rotatedaround(origin,240) ; +% +% pushcurrentpicture ; +% +% fill fullcircle scaled radius withcolor white ; +% +% fill rr withcolor red ; fill cc withcolor white-red ; +% fill gg withcolor green ; fill mm withcolor white-green ; +% fill bb withcolor blue ; fill yy withcolor white-blue ; +% +% for i = rr,gg,bb,cc,mm,yy : draw i withcolor .5white ; endfor ; +% +% currentpicture := currentpicture xsized size ; +% +% popcurrentpicture ; +% enddef ; + +% vardef colorcircle (expr size, red, green, blue) = +% save r, g, b, rr, gg, bb, cc, mm, yy ; save radius ; +% path r, g, b, rr, bb, gg, cc, mm, yy ; numeric radius ; +% +% radius := 5cm ; pickup pencircle scaled (radius/25) ; +% +% transform t ; t := identity rotatedaround(origin,120) ; +% +% r := fullcircle scaled radius +% shifted (0,radius/4) rotatedaround(origin,15) ; +% +% g := r transformed t ; b := g transformed t ; +% +% r := r rotatedaround(center r,-90) ; +% g := g rotatedaround(center g, 90) ; +% +% gg := buildcycle(buildcycle(reverse r,b),g) ; +% cc := buildcycle(buildcycle(b,reverse g),r) ; +% +% rr := gg transformed t ; bb := rr transformed t ; +% yy := cc transformed t ; mm := yy transformed t ; +% +% pushcurrentpicture ; +% +% fill fullcircle scaled radius withcolor white ; +% +% fill rr withcolor red ; fill cc withcolor white-red ; +% fill gg withcolor green ; fill mm withcolor white-green ; +% fill bb withcolor blue ; fill yy withcolor white-blue ; +% +% for i = rr,gg,bb,cc,mm,yy : draw i withcolor .5white ; endfor ; +% +% currentpicture := currentpicture xsized size ; +% +% popcurrentpicture ; +% enddef ; + +vardef colorcircle (expr size, red, green, blue) = + save r, g, b, c, m, y, w ; save radius ; + path r, g, b, c, m, y, w ; numeric radius ; + + radius := 5cm ; pickup pencircle scaled (radius/25) ; + + transform t ; t := identity rotatedaround(origin,120) ; + + r := fullcircle rotated 90 scaled radius + shifted (0,radius/4) rotatedaround(origin,135) ; + + b := r transformed t ; g := b transformed t ; + + c := buildcycle(subpath(1,7) of g,subpath(1,7) of b) ; + y := c transformed t ; m := y transformed t ; + + w := buildcycle(subpath(3,5) of r, subpath(3,5) of g,subpath(3,5) of b) ; + + pushcurrentpicture ; + + fill r withcolor red ; + fill g withcolor green ; + fill b withcolor blue ; + fill c withcolor white-red ; + fill m withcolor white-green ; + fill y withcolor white-blue ; + fill w withcolor white ; + + for i = r,g,b,c,m,y : draw i withcolor .5white ; endfor ; + + currentpicture := currentpicture xsized size ; + + popcurrentpicture ; +enddef ; + +% penpoint (i,2) of somepath -> inner / outer point + +vardef penpoint expr pnt of p = + save n, d ; numeric n, d ; + (n,d) = if pair pnt : pnt else : (pnt,1) fi ; + (point n of p shifted ((penoffset direction n of p of currentpen) scaled d)) +enddef ; + +% nice: currentpicture := inverted currentpicture ; + +primarydef p uncolored c = + image + (for i within p : + addto currentpicture + if stroked i or filled i : + if filled i : contour else : doublepath fi pathpart i + dashed dashpart i withpen penpart i + else : + also i + fi + withcolor c-(redpart i, greenpart i, bluepart i) ; + endfor ; ) +enddef ; + +vardef inverted primary p = + (p uncolored white) +enddef ; + +primarydef p softened c = + image + (save cc ; color cc ; cc := tripled(c) ; + for i within p : + addto currentpicture + if stroked i or filled i : + if filled i : contour else : doublepath fi pathpart i + dashed dashpart i withpen penpart i + else : + also i + fi + withcolor (redpart cc * redpart i, + greenpart cc * greenpart i, + bluepart cc * bluepart i) ; + endfor ;) +enddef ; + +vardef grayed primary p = + image + (for i within p : + addto currentpicture + if stroked i or filled i : + if filled i : contour else : doublepath fi pathpart i + dashed dashpart i withpen penpart i + else : + also i + fi + withcolor tripled(.30redpart i+.59greenpart i+.11bluepart i) ; + endfor ; ) +enddef ; + +% yes or no: "text" infont "cmr12" at 24pt ; + +% let normalinfont = infont ; +% +% numeric lastfontsize ; lastfontsize = fontsize defaultfont ; +% +% def infont primary name = % no vardef, no expr +% hide(lastfontsize := fontsize name) % no ; +% normalinfont name +% enddef ; +% +% def scaledat expr size = +% scaled (size/lastfontsize) +% enddef ; +% +% let at = scaledat ; + +% like decimal + +def condition primary b = if b : "true" else : "false" fi enddef ; + +% undocumented + +primarydef p stretched s = + begingroup +% save pp ; path pp ; pp := p scaled s ; + save pp ; path pp ; pp := p xyscaled s ; + (pp shifted ((point 0 of p) - (point 0 of pp))) + endgroup +enddef ; + +% yes or no, untested -) + +def xshifted expr dx = shifted(dx,0) enddef ; +def yshifted expr dy = shifted(0,dy) enddef ; + +% also handy + +% right: str = readfrom ("abc" & ".def" ) ; +% wrong: str = readfrom "abc" & ".def" ; + +% Every 62th read fails so we need to try again! + +def readfile (expr name) = + if (readfrom (name) <> EOF) : + scantokens("input " & name & " ") ; + elseif (readfrom (name) <> EOF) : + scantokens("input " & name & " ") ; + fi + closefrom (name) ; +enddef ; + +% permits redefinition of end in macro + +inner end ; + +% real fun + +let normalwithcolor = withcolor ; + +def remapcolors = + def withcolor primary c = normalwithcolor remappedcolor(c) enddef ; +enddef ; + +def normalcolors = + let withcolor = normalwithcolor ; +enddef ; + +def resetcolormap = + color color_map[][][] ; + normalcolors ; +enddef ; + +resetcolormap ; + +% color_map_resolution := 1000 ; +% +% def r_color primary c = round(color_map_resolution*redpart c) enddef ; +% def g_color primary c = round(color_map_resolution*greenpart c) enddef ; +% def b_color primary c = round(color_map_resolution*bluepart c) enddef ; + +def r_color primary c = redpart c enddef ; +def g_color primary c = greenpart c enddef ; +def b_color primary c = bluepart c enddef ; + +def remapcolor(expr old, new) = + color_map[r_color old][g_color old][b_color old] := new ; +enddef ; + +def remappedcolor(expr c) = + if known color_map[r_color c][g_color c][b_color c] : + color_map[r_color c][g_color c][b_color c] + else : + c + fi +enddef ; + +% def refill suffix c = do_repath (1) (c) enddef ; +% def redraw suffix c = do_repath (2) (c) enddef ; +% def recolor suffix c = do_repath (0) (c) enddef ; +% +% color refillbackground ; refillbackground := (1,1,1) ; +% +% def do_repath (expr mode) (suffix c) text t = % can it be stroked and filled at the same time ? +% begingroup ; +% if mode=0 : save withcolor ; remapcolors ; fi ; +% save _c_, _cc_, _f_, _b_ ; picture _c_, _cc_ ; color _f_ ; path _b_ ; +% _c_ := c ; _b_ := boundingbox c ; c := nullpicture ; +% for i within _c_ : +% _f_ := (redpart i, greenpart i, bluepart i) ; +% if bounded i : +% setbounds c to pathpart i ; +% elseif clipped i : +% clip c to pathpart i ; +% elseif stroked i : +% addto c doublepath pathpart i +% dashed dashpart i withpen penpart i +% withcolor _f_ % (redpart i, greenpart i, bluepart i) +% if mode=2 : t fi ; +% elseif filled i : +% addto c contour pathpart i +% withcolor _f_ +% if (mode=1) and (_f_<>refillbackground) : t fi ; +% else : +% addto c also i ; +% fi ; +% endfor ; +% setbounds c to _b_ ; +% endgroup ; +% enddef ; + +% Thanks to Jens-Uwe Morawski for pointing out that we need +% to treat bounded and clipped components as local pictures. + +def recolor suffix p = p := repathed (0,p) enddef ; +def refill suffix p = p := repathed (1,p) enddef ; +def redraw suffix p = p := repathed (2,p) enddef ; +def retext suffix p = p := repathed (3,p) enddef ; +def untext suffix p = p := repathed (4,p) enddef ; + +primarydef p recolored t = repathed(0,p) t enddef ; +primarydef p refilled t = repathed(1,p) t enddef ; +primarydef p redrawn t = repathed(2,p) t enddef ; +primarydef p retexted t = repathed(3,p) t enddef ; +primarydef p untexted t = repathed(4,p) t enddef ; + +color refillbackground ; refillbackground := (1,1,1) ; + +vardef repathed (expr mode, p) text t = + begingroup ; + if mode=0 : save withcolor ; remapcolors ; fi ; + save _p_, _pp_, _f_, _b_, _t_ ; + picture _p_, _pp_ ; color _f_ ; path _b_ ; transform _t_ ; + _b_ := boundingbox p ; _p_ := nullpicture ; + for i within p : + _f_ := (redpart i, greenpart i, bluepart i) ; + if bounded i : + _pp_ := repathed(mode,i) t ; + setbounds _pp_ to pathpart i ; + addto _p_ also _pp_ ; + elseif clipped i : + _pp_ := repathed(mode,i) t ; + clip _pp_ to pathpart i ; + addto _p_ also _pp_ ; + elseif stroked i : + addto _p_ doublepath pathpart i + dashed dashpart i withpen penpart i + withcolor _f_ % (redpart i, greenpart i, bluepart i) + if mode=2 : t fi ; + elseif filled i : + addto _p_ contour pathpart i + withcolor _f_ + if (mode=1) and (_f_<>refillbackground) : t fi ; + elseif textual i : % textpart i <> "" : + if mode <> 4 : + % transform _t_ ; + % (xpart _t_, xxpart _t_, xypart _t_) = (xpart i, xxpart i, xypart i) ; + % (ypart _t_, yypart _t_, yxpart _t_) = (ypart i, yypart i, yxpart i) ; + % addto _p_ also + % textpart i infont fontpart i % todo : other font + % transformed _t_ + % withpen penpart i + % withcolor _f_ + % if mode=3 : t fi ; + addto _p_ also i if mode=3 : t fi ; + fi ; + else : + addto _p_ also i ; + fi ; + endfor ; + setbounds _p_ to _b_ ; + _p_ + endgroup +enddef ; + + + + +% After a question of Denis on how to erase a z variable, Jacko +% suggested to assign whatever to x and y. So a clearz +% variable can be defined as: +% +% vardef clearz@# = +% x@# := whatever ; +% y@# := whatever ; +% enddef ; +% +% but Jacko suggested a redefinition of clearxy: +% +% def clearxy text s = +% clearxy_index_:=0; +% for $:=s: +% clearxy_index_:=clearxy_index_+1; endfor; +% if clearxy_index_=0: +% save x,y; +% else: +% forsuffixes $:=s: x$:=whatever; y$:=whatever; endfor; +% fi +% enddef; +% +% which i decided to simplify to: + +def clearxy text s = + if false for $ := s : or true endfor : + forsuffixes $ := s : x$ := whatever ; y$ := whatever ; endfor ; + else : + save x, y ; + fi +enddef ; + +% so now we can say: clearxy ; as well as clearxy 1, 2, 3 ; + +% show x0 ; z0 = (10,10) ; +% show x0 ; x0 := whatever ; y0 := whatever ; +% show x0 ; z0 = (20,20) ; +% show x0 ; clearxy 0 ; +% show x0 ; z0 = (30,30) ; + +primarydef p smoothed d = + (p llmoved (-xpart paired(d),0) -- p lrmoved (-xpart paired(d),0) {right} .. + p lrmoved (0,-ypart paired(d)) -- p urmoved (0,-ypart paired(d)) {up} .. + p urmoved (-xpart paired(d),0) -- p ulmoved (-xpart paired(d),0) {left} .. + p ulmoved (0,-ypart paired(d)) -- p llmoved (0,-ypart paired(d)) {down} .. cycle) +enddef ; + +primarydef p cornered c = + ((point 0 of p) shifted (c*(unitvector(point 1 of p - point 0 of p))) -- + for i=1 upto length(p) : + (point i-1 of p) shifted (c*(unitvector(point i of p - point i-1 of p))) -- + (point i of p) shifted (c*(unitvector(point i-1 of p - point i of p))) .. + controls point i of p .. + endfor cycle) +enddef ; + +% cmyk color support + +vardef cmyk(expr c,m,y,k) = + (1-c-k,1-m-k,1-y-k) +enddef ; + +% handy + +vardef bbwidth (expr p) = + (if known p : + if path p or picture p : + xpart (lrcorner p - llcorner p) + else : 0 fi else : 0 + fi ) +enddef ; + +vardef bbheight (expr p) = + (if known p : if path p or picture p : + ypart (urcorner p - lrcorner p) + else : 0 fi else : 0 + fi) +enddef ; + +color nocolor ; numeric noline ; % both unknown signals + +def dowithpath (expr p, lw, lc, bc) = + if known p : + if known bc : + fill p withcolor bc ; + fi ; + if known lw and known lc : + draw p withpen pencircle scaled lw withcolor lc ; + elseif known lw : + draw p withpen pencircle scaled lw ; + elseif known lc : + draw p withcolor lc ; + fi ; + fi ; +enddef ; + +% result from metafont discussion list (denisr/boguslawj) + +def ]] = ] ] enddef ; def ]]] = ] ] ] enddef ; +def [[ = [ [ enddef ; def [[[ = [ [ [ enddef ; + +% not prefect, but useful since it removes redundant points. + +vardef dostraightened(expr sign, p) = + if length(p)>2 : % was 1, but straight lines are ok + save pp ; path pp ; + pp := point 0 of p ; + for i=1 upto length(p)-1 : + if round(point i of p) <> round(point length(pp) of pp) : + pp := pp -- point i of p ; + fi ; + endfor ; + save n, ok ; numeric n ; boolean ok ; + n := length(pp) ; ok := false ; +if n>2 : + for i=0 upto n : % evt hier ook round + + if unitvector(round(point i of pp - + point if i=0 : n else : i-1 fi of pp)) <> + sign * unitvector(round(point if i=n : 0 else : i+1 fi of pp - + point i of pp)) : + if ok : -- else : ok := true ; fi point i of pp + fi + + endfor + if ok and (cycle p) : -- cycle fi +else : + pp +fi + else : + p + fi +enddef ; + +% simplified : remove same points as well as redundant points +% unspiked : remove same points as well as areas with zero distance + +% vardef simplified expr p = dostraightened(+1,p) enddef ; +% vardef unspiked expr p = dostraightened(-1,p) enddef ; + +vardef simplified expr p = + (reverse dostraightened(+1,dostraightened(+1,reverse p))) +enddef ; + +vardef unspiked expr p = + (reverse dostraightened(-1,dostraightened(-1,reverse p))) +enddef ; + +% path p ; +% p := (2cm,1cm) -- (2cm,1cm) -- (2cm,1cm) -- (3cm,1cm) -- +% (4cm,1cm) -- (4cm,2cm) -- (4cm,2.5cm) -- (4cm,3cm) -- +% (3cm,3cm) -- (2cm,3cm) -- (1cm,3cm) -- (-1cm,3cm) -- +% .5[(-1cm,3cm),(1cm,1cm)] -- (1cm,1cm) -- cycle ; +% +% p := unitcircle scaled 4cm ; +% +% drawpath p ; drawpoints p ; drawpointlabels p ; +% p := p shifted (4cm,0) ; p := straightened p ; +% drawpath p ; drawpoints p ; drawpointlabels p ; +% p := p shifted (4cm,0) ; p := straightened p ; +% drawpath p ; drawpoints p ; drawpointlabels p ; + +% new + +path originpath ; originpath := origin -- cycle ; + +vardef unitvector primary z = + if abs z = abs origin : z else : z/abs z fi +enddef; + +% also new + +vardef anchored@#(expr p, z) = + p shifted (z + (labxf@#*lrcorner p + labyf@#*ulcorner p + + (1-labxf@#-labyf@#)*llcorner p)) +enddef ; + +% epsed(1.2345) + +vardef epsed (expr e) = + e if e>0 : + eps elseif e<0 : - eps fi +enddef ; + +% handy + +def withgray primary g = + withcolor (g,g,g) +enddef ; + +% for metafun + +if unknown darkred : color darkred ; darkred := .625(1,0,0) fi ; +if unknown darkyellow : color darkyellow ; darkyellow := .625(1,1,0) fi ; +if unknown darkgray : color darkgray ; darkgray := .625(1,1,1) fi ; +if unknown lightgray : color lightgray ; lightgray := .875(1,1,1) fi ; + +% an improved plain mp macro + +vardef center primary p = + if pair p : p else : .5[llcorner p, urcorner p] fi +enddef; + +% new, yet undocumented + +vardef rangepath (expr p, d, a) = + (if length p>0 : + (d*unitvector(direction 0 of p) rotated a) + shifted point 0 of p + -- p -- + (d*unitvector(direction length(p) of p) rotated a) + shifted point length(p) of p + else : + p + fi) +enddef ; + +% under construction + +vardef straightpath(expr a, b, method) = + if (method<1) or (method>6) : + (a--b) + elseif method = 1 : + (a -- + if xpart a > xpart b : + if ypart a > ypart b : + (xpart b,ypart a) -- + elseif ypart a < ypart b : + (xpart a,ypart b) -- + fi + elseif xpart a < xpart b : + if ypart a > ypart b : + (xpart a,ypart b) -- + elseif ypart a < ypart b : + (xpart b,ypart a) -- + fi + fi + b) + elseif method = 3 : + (a -- + if xpart a > xpart b : + (xpart b,ypart a) -- + elseif xpart a < xpart b : + (xpart a,ypart b) -- + fi + b) + elseif method = 5 : + (a -- + if ypart a > ypart b : + (xpart b,ypart a) -- + elseif ypart a < ypart b : + (xpart a,ypart b) -- + fi + b) + else : + (reverse straightpath(b,a,method-1)) + fi +enddef ; + +% handy for myself + +def addbackground text t = + begingroup ; save p ; picture p ; + p := currentpicture ; currentpicture := nullpicture ; + fill boundingbox p t ; addto currentpicture also p ; + endgroup ; +enddef ; + +% makes a (line) into an infinite one (handy for calculating +% intersection points + +vardef infinite expr p = + (-infinity*unitvector(direction 0 of p) + shifted point 0 of p + -- p -- + +infinity*unitvector(direction length(p) of p) + shifted point length(p) of p) +enddef ; + +% obscure macros: create var from string and replace - and : +% (needed for process color id's) + +string _clean_ascii[] ; + +_clean_ascii[ASCII "-"] := "_" ; +_clean_ascii[ASCII ":"] := "_" ; +_clean_ascii[ASCII "."] := "_" ; + +vardef cleanstring (expr s) = + save ss ; string ss, si ; ss = "" ; + for i=0 upto length(s) : + si := substring(i,i+1) of s ; + ss := ss & if known _clean_ascii[ASCII si] : _clean_ascii[ASCII si] else : si fi ; + endfor ; + ss +enddef ; + +vardef setunstringed (expr s, v) = + scantokens(cleanstring(s)) := v ; +enddef ; + +vardef setunstringed (expr s, v) = + scantokens(cleanstring(s)) := v ; +enddef ; + +vardef getunstringed (expr s) = + scantokens(cleanstring(s)) +enddef ; + +vardef unstringed (expr s) = + expandafter known scantokens(cleanstring(s)) +enddef ; + +% new + +vardef colorpart(expr i) = + (redpart i, greenpart i,bluepart i) +enddef ; + + +% done + +endinput ; diff --git a/metapost/context/metafun.mp b/metapost/context/metafun.mp deleted file mode 100644 index 474a10eb3..000000000 --- a/metapost/context/metafun.mp +++ /dev/null @@ -1,47 +0,0 @@ -%D \module -%D [ file=metafun.mp, -%D version=2000.07.15, -%D title=\CONTEXT\ \METAPOST\ graphics, -%D subtitle=format generation file, -%D author=Hans Hagen, -%D date=\currentdate, -%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] -%C -%C This module is part of the \CONTEXT\ macro||package and is -%C therefore copyrighted by \PRAGMA. See mreadme.pdf for -%C details. - -%D When generating many graphics at runtime, it can save run -%D time to use a format file. We could have named this file -%D \type {context}, but this is error prone, because it forces -%D to use the progname \type {mpost} or \type {context} -%D explicitly, depending on the needs. When using the format, -%D a mismatch in the memory specification of \type {mpost} or -%D \type {context} (the \TEX\ one) could lead to lost strings -%D (and as a result in buggy boundingbox and special -%D handling). By using the name \type {metatex} we make sure -%D that we use (unless overloaded) the settings of \type -%D {mpost}. - -if unknown ahangle : - input plain.mp ; % John Hobby's file -else : - let dump = relax ; -fi ; - -input mp-tool.mp ; -input mp-spec.mp ; -input mp-core.mp ; -input mp-page.mp ; -input mp-text.mp ; -input mp-shap.mp ; -input mp-butt.mp ; -input mp-char.mp ; -input mp-step.mp ; -input mp-grph.mp ; - -% mp-form.mp ; -input mp-grid.mp ; -input mp-func.mp ; - -dump ; endinput . diff --git a/metapost/context/mp-back.mp b/metapost/context/mp-back.mp deleted file mode 100644 index 99e88554b..000000000 --- a/metapost/context/mp-back.mp +++ /dev/null @@ -1,206 +0,0 @@ -%D \module -%D [ file=mp-back.mp, -%D version=2000.05.31, -%D title=\CONTEXT\ \METAPOST\ graphics, -%D subtitle=backgrounds, -%D author=Hans Hagen, -%D date=\currentdate, -%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] -%C -%C This module is part of the \CONTEXT\ macro||package and is -%C therefore copyrighted by \PRAGMA. See licen-en.pdf for -%C details. - -if unknown context_tool : input mp-tool ; fi ; -if known context_back : endinput ; fi ; - -boolean context_back ; context_back := true ; - -def some_hash ( expr hash_width , - hash_height , - hash_linewidth , - hash_linecolor , - hash_angle , - hash_gap ) = - - stripe_gap := hash_gap ; - stripe_angle := hash_angle ; - drawoptions (withpen pencircle scaled hash_linewidth - withcolor hash_linecolor) ; - path p ; p := unitsquare xscaled hash_width yscaled hash_height ; - stripe_path_a () (draw) p ; % next we move it all to quadrant 1 - currentpicture := currentpicture shifted urcorner currentpicture ; - -enddef ; - -def some_double_back (expr back_type , - back_width , - back_height , - back_delta , - back_linewidth , - back_linecolor , - back_fillcolor , - back_topcolor , - back_bottomcolor , - back_leftcolor , - back_rightcolor ) = - - numeric ww ; ww := back_width ; - numeric hh ; hh := back_height ; - numeric dd ; dd := back_delta ; - - color back_nillcolor ; back_nillcolor := back_topcolor ; - - path p ; p := fullsquare xscaled ww yscaled hh ; - path q ; q := fullsquare xscaled (ww-2dd) yscaled (hh-2dd) ; - path r ; r := llcorner p -- - lrcorner p shifted (-3dd,0) .. controls lrcorner p .. - lrcorner p shifted (0, 3dd) -- - urcorner p shifted (0,-3dd) .. controls urcorner p .. - urcorner p shifted (-3dd,0) -- - ulcorner p -- cycle ; - path s ; s := r xscaled ((ww-2dd)/ww) yscaled ((hh-2dd)/hh) ; - path t ; t := llcorner p -- - lrcorner p -- - urcorner p shifted (0,-3dd) .. controls urcorner p .. - urcorner p shifted (-3dd,0) -- - ulcorner p shifted ( 3dd,0) .. controls ulcorner p .. - ulcorner p shifted (0,-3dd) -- - llcorner p -- cycle ; - path u ; u := t xscaled ((ww-2dd)/ww) yscaled ((hh-2dd)/hh) ; - path v ; v := llcorner p shifted ( 3dd,0) -- - lrcorner p shifted (-3dd,0) .. controls lrcorner p .. - lrcorner p shifted (0, 3dd) -- - urcorner p shifted (0,-3dd) .. controls urcorner p .. - urcorner p shifted (-3dd,0) -- - ulcorner p shifted ( 3dd,0) .. controls ulcorner p .. - ulcorner p shifted (0,-3dd) .. - llcorner p shifted (0, 3dd) .. controls llcorner p .. cycle ; % {down} .. cycle ; - path w ; w := t xscaled ((ww-2dd)/ww) yscaled ((hh-2dd)/hh) ; - path a ; a := llcorner p -- ulcorner p -- - ulcorner q -- llcorner q -- cycle ; - path b ; b := llcorner p -- lrcorner p -- - lrcorner q -- llcorner q -- cycle ; - path c ; c := lrcorner p -- urcorner p -- - urcorner q -- lrcorner q -- cycle ; - path d ; d := ulcorner p -- urcorner p -- - urcorner q -- ulcorner q -- cycle ; - path e ; e := llcorner p -- lrcorner p -- - urcorner p -- urcorner q -- - lrcorner q -- llcorner q -- cycle ; - path f ; f := llcorner p -- ulcorner p -- - urcorner p -- urcorner q -- - ulcorner q -- llcorner q -- cycle ; - - linecap := butt ; pickup pencircle scaled back_linewidth ; - - if back_type=1 : - - fill p withcolor back_fillcolor ; - fill a withcolor back_leftcolor ; - fill b withcolor back_bottomcolor ; - fill c withcolor back_rightcolor ; - fill d withcolor back_topcolor ; - draw a withcolor back_linecolor ; - draw d withcolor back_linecolor ; - draw b withcolor back_linecolor ; - draw c withcolor back_linecolor ; - - elseif back_type=2 : - - fill p withcolor back_fillcolor ; - fill e withcolor back_bottomcolor ; - fill f withcolor back_topcolor ; - draw e withcolor back_linecolor ; - draw f withcolor back_linecolor ; - - elseif back_type=3 : - - fill v withcolor back_nillcolor ; - fill w withcolor back_fillcolor ; - draw v withcolor back_linecolor ; - draw w withcolor back_linecolor ; - - elseif back_type=4 : - - fill t withcolor back_nillcolor ; - fill u withcolor back_fillcolor ; - draw t withcolor back_linecolor ; - draw u withcolor back_linecolor ; - - elseif back_type=5 : - - t := t rotatedaround(center t,180) ; - u := u rotatedaround(center u,180) ; - - fill t withcolor back_nillcolor ; - fill u withcolor back_fillcolor ; - draw t withcolor back_linecolor ; - draw u withcolor back_linecolor ; - - elseif back_type=6 : - - r := r rotatedaround(center r,180) ; - s := s rotatedaround(center s,180) ; - - fill r withcolor back_nillcolor ; - fill s withcolor back_fillcolor ; - draw r withcolor back_linecolor ; - draw s withcolor back_linecolor ; - - elseif back_type=7 : - - fill r withcolor back_nillcolor ; - fill s withcolor back_fillcolor ; - draw r withcolor back_linecolor ; - draw s withcolor back_linecolor ; - -fi ; - -enddef ; - -endinput ; - -beginfig (1) ; - -some_double_back (1, 4.5cm, 1.5cm, .25cm, 1mm, - .5white, .8white, .7white, .6white, .7white, .6white) - -currentpicture := currentpicture shifted (0,-3cm) ; - -some_double_back (2, 4.5cm, 1.5cm, .25cm, 1mm, - .5white, .8white, .7white, .6white, white, white) - -currentpicture := currentpicture shifted (0,-3cm) ; - -some_double_back (3, 4.5cm, 1.5cm, .25cm, 1mm, - .5white, .8white, .7white, white, white, white) - -currentpicture := currentpicture shifted (0,-3cm) ; - -some_double_back (4, 4.5cm, 1.5cm, .25cm, 1mm, - .5white, .8white, .7white, white, white, white) - -currentpicture := currentpicture shifted (0,-3cm) ; - -some_double_back (5, 4.5cm, 1.5cm, .25cm, 1mm, - .5white, .8white, .7white, white, white, white) - -currentpicture := currentpicture shifted (0,-3cm) ; - -some_double_back (6, 4.5cm, 1.5cm, .25cm, 1mm, - .5white, .8white, .7white, white, white, white) - -currentpicture := currentpicture shifted (0,-3cm) ; - -some_double_back (7, 4.5cm, 1.5cm, .25cm, 1mm, - .5white, .8white, .7white, white, white, white) - -currentpicture := currentpicture shifted (0,-3cm) ; - -some_double_back (8, 4.5cm, 1.5cm, .25cm, 1mm, - .5white, .8white, .7white, white, white, white) - -endfig ; - -end . diff --git a/metapost/context/mp-butt.mp b/metapost/context/mp-butt.mp deleted file mode 100644 index cf580211e..000000000 --- a/metapost/context/mp-butt.mp +++ /dev/null @@ -1,75 +0,0 @@ -%D \module -%D [ file=mp-butt.mp, -%D version=2000.05.31, -%D title=\CONTEXT\ \METAPOST\ graphics, -%D subtitle=buttons, -%D author=Hans Hagen, -%D date=\currentdate, -%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] -%C -%C This module is part of the \CONTEXT\ macro||package and is -%C therefore copyrighted by \PRAGMA. See licen-en.pdf for -%C details. - -if unknown context_tool : input mp-tool ; fi ; -if known context_butt : endinput ; fi ; - -boolean context_butt ; context_butt := true ; - -def some_button (expr button_type , - button_size , - button_linecolor , - button_fillcolor ) = - - numeric button_linewidth ; button_linewidth := button_size/10 ; - - drawoptions (withpen pencircle scaled button_linewidth - withcolor button_linecolor) ; - - path p ; p := unitsquare scaled button_size ; - numeric d ; d := button_size ; - numeric l ; l := button_linewidth ; - - fill p withcolor button_fillcolor ; draw p ; - - if button_type=101 : - draw (d-2l,2l)--(2l,.5d)--(d-2l,d-2l)--cycle ; - elseif button_type=102 : - draw (2l,2l)--(d-2l,.5d)--(2l,d-2l)--cycle ; - elseif button_type=103 : - for i=2l step 2l until d-2l : - draw (2l,i)--(2l ,i) ; - draw (4l,i)--(d-2l,i) ; - endfor ; - elseif button_type=104 : - for i=2l step 2l until d-2l : - draw (2l ,i)--(d/2-l,i) ; - draw (d/2+l,i)--(d-2l ,i) ; - endfor ; - elseif button_type=105 : - fill fullcircle scaled (.2d) shifted (.5d,.7d) ; - fill fullcircle xscaled (.6d) yscaled d shifted (.5d,0) ; - clip currentpicture to p ; - draw p ; - elseif button_type=106 : - draw (2l,2l)--(d-2l,d-2l) ; - draw (d-2l,2l)--(2l,d-2l) ; - elseif button_type=107 : - p := (3l,d-2l)--(d-3l,d-2l)--(.5d,4l)--cycle ; - fill p ; draw p ; - draw (.5d,2l) ; - elseif button_type=108 : - draw (.5d,2l)--(d-2l,d-2l)--(2l,d-2l)--cycle ; - elseif button_type=109 : - draw (.5d,d-2l)--(d-2l,2l)--(2l,2l)--cycle ; - elseif button_type=110 : - button_linewidth := button_linewidth/2 ; - draw p enlarged (-2l,-l) ; - for i=2l step l until d-2l : - draw (3l,i)--(d-3l,i) ; - endfor ; - fi ; - -enddef ; - -endinput ; diff --git a/metapost/context/mp-char.mp b/metapost/context/mp-char.mp deleted file mode 100644 index 9416b1349..000000000 --- a/metapost/context/mp-char.mp +++ /dev/null @@ -1,997 +0,0 @@ -% to be cleaned up, namespace needed ! ! ! ! ! - -%D \module -%D [ file=mp-char.mp, -%D version=1998.10.10, -%D title=\CONTEXT\ \METAPOST\ graphics, -%D subtitle=charts, -%D author=Hans Hagen, -%D date=\currentdate, -%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] -%C -%C This module is part of the \CONTEXT\ macro||package and is -%C therefore copyrighted by \PRAGMA. See licen-en.pdf for -%C details. - -if unknown context_tool : input mp-tool ; fi ; -if unknown context_shap : input mp-shap ; fi ; -if known context_char : endinput ; fi ; - -boolean context_char ; context_char := true ; - -% kan naar elders - -current_position := 0 ; - -def save_text_position (expr p) = % beware: clip shift needed - current_position := current_position + 1 ; - savedata - "\MPposition{" & decimal current_position & "}{" - & decimal xpart p & "}{" - & decimal ypart p & "}" ; -enddef ; - -%D settings - -grid_width := 60pt ; grid_height := 40pt ; -shape_width := 45pt ; shape_height := 30pt ; - -chart_offset := 2pt ; - -color chart_background_color ; chart_background_color := white ; - -%D test mode - -boolean show_mid_points ; show_mid_points := false ; -boolean show_con_points ; show_con_points := false ; -boolean show_all_points ; show_all_points := false ; - -%D shapes - -color shape_line_color, shape_fill_color ; - -shape_line_width := 2pt ; -shape_line_color := .5white ; -shape_fill_color := .9white ; - -shape_node := 0 ; -shape_action := 24 ; -shape_procedure := 5 ; -shape_product := 12 ; -shape_decision := 14 ; -shape_archive := 19 ; -shape_loop := 35 ; -shape_wait := 6 ; -shape_subprocedure := 20 ; shape_sub_procedure := 20 ; -shape_singledocument := 32 ; shape_single_document := 32 ; -shape_multidocument := 33 ; shape_multi_document := 33 ; -shape_right := 66 ; -shape_left := 67 ; -shape_up := 68 ; -shape_down := 69 ; - -% vardef some_shape_path (expr type) == imported from mp-shap - -def show_shapes (expr n) = - - begin_chart(n,8,10) ; - show_con_points := true ; - for i=0 upto 7 : - for j=0 upto 9 : - new_shape(i+1,j+1,i*10+j); - endfor ; - endfor ; - end_chart ; - -enddef ; - -%D connections - -def new_chart = - - color connection_line_color ; - - connection_line_width := shape_line_width ; - connection_line_color := .8white ; - connection_smooth_size := 5pt ; - connection_arrow_size := 4pt ; - connection_dash_size := 3pt ; - - max_x := 6 ; - max_y := 4 ; - - numeric xypoint ; xypoint := 0 ; - - pair xypoints [] ; - - boolean xyfree [][] ; - path xypath [][] ; - numeric xysx [][] ; - numeric xysy [][] ; - color xyfill [][] ; - color xydraw [][] ; - numeric xyline [][] ; - boolean xypeep [][] ; - - numeric cpath ; cpath := 0 ; - path cpaths [] ; - numeric cline [] ; - color ccolor [] ; - boolean carrow [] ; - boolean cdash [] ; - boolean ccross [] ; - - boolean smooth ; smooth := true ; - boolean peepshape ; peepshape := false ; - boolean arrowtip ; arrowtip := true ; - boolean dashline ; dashline := false ; - boolean forcevalid ; forcevalid := false ; - boolean touchshape ; touchshape := false ; - boolean showcrossing ; showcrossing := false ; - - picture dash_pattern ; - - boolean reverse_y ; reverse_y := true ; - -enddef ; - -new_chart ; - -def y_pos (expr y) = - if reverse_y : max_y + 1 - y else : y fi -enddef ; - -def initialize_grid (expr maxx, maxy) = - begingroup ; - save i, j ; - max_x := maxx ; - max_y := maxy ; - dsp_x := 0 ; - dsp_y := 0 ; - for x=1 upto max_x : - for y=1 upto max_y : - xyfree [x][y] := true ; - xyfill [x][y] := shape_fill_color ; - xydraw [x][y] := shape_line_color ; - xyline [x][y] := shape_line_width ; - endfor ; - endfor ; - endgroup ; -enddef ; - -def scaled_to_grid = - xscaled grid_width yscaled grid_height -enddef ; - -def xy_offset (expr x, y) = - (x+.5,y+.5) -enddef ; - -def draw_shape (expr x, yy, p, sx, sy) = - begingroup ; - save y ; - y := y_pos(yy) ; - xypath [x][y] := (p xscaled sx yscaled sy) shifted xy_offset(x,y) ; - xyfree [x][y] := false ; - xysx [x][y] := sx ; - xysy [x][y] := sy ; - xyfill [x][y] := shape_fill_color ; - xydraw [x][y] := shape_line_color ; - xyline [x][y] := shape_line_width ; - xypeep [x][y] := peepshape ; - endgroup ; -enddef ; - -vardef i_point (expr x, y, p, t) = - begingroup ; - save q, ok ; - pair q ; - boolean ok ; - q := xypath[x][y] intersection_point ((p) shifted xy_offset(x,y)) ; - ok := true ; -% if xpart q < -.5 : ok := false ; q := (-.45,ypart q) fi ; -% if xpart q > .5 : ok := false ; q := ( .45,ypart q) fi ; -% if ypart q < -.5 : ok := false ; q := (xpart q,-.45) fi ; -% if ypart q > .5 : ok := false ; q := (xpart q, .45) fi ; - if not ok : - message (t & " of shape (" & decimal x & "," & decimal y & ") limited") ; - fi ; - q - endgroup -enddef ; - -vardef trimmed (expr x, y, z, t) = - if touchshape and t : xyline[x][y]/z else : epsilon fi -enddef ; - -zfactor := 1/3 ; - -vardef xy_bottom (expr x, y, z, t) = - i_point (x, y, ((0,0)--(0,-2)) shifted (zfactor*z*xysx[x][y],0), "bottom") - shifted(0,-trimmed(x,y,grid_height,t)) -enddef ; - -vardef xy_top (expr x, y, z, t) = - i_point (x, y, ((0,0)--(0,2)) shifted (zfactor*z*xysx[x][y],0), "top") - shifted(0,trimmed(x,y,grid_height,t)) -enddef ; - -vardef xy_left (expr x, y, z, t) = - i_point (x, y, ((0,0)--(-2,0)) shifted (0,zfactor*z*xysy[x][y]), "left") - shifted(-trimmed(x,y,grid_width,t),0) -enddef ; - -vardef xy_right (expr x, y, z, t) = - i_point (x, y, ((0,0)--(2,0)) shifted (0,zfactor*z*xysy[x][y]), "right") - shifted(trimmed(x,y,grid_width,t),0) -enddef ; - -def flush_shapes = - for x=1 upto max_x : - for y=1 upto max_y : - flush_shape (x, y) ; - endfor ; - endfor ; -enddef ; - -def draw_connection_point (expr x, y, z) = - pickup pencircle scaled if (z=0): 2 fi xyline[x][y] ; - drawdot xy_bottom(x,y,z,false) scaled_to_grid withcolor (1,0,0) ; - drawdot xy_top (x,y,z,false) scaled_to_grid withcolor (0,1,0) ; - drawdot xy_left (x,y,z,false) scaled_to_grid withcolor (0,0,1) ; - drawdot xy_right (x,y,z,false) scaled_to_grid withcolor (1,1,0) ; -enddef ; - -def flush_shape (expr x, yy) = - begingroup ; - save y ; - y := y_pos(yy) ; - if not xyfree[x][y] : - pickup pencircle scaled xyline[x][y] ; - if xypeep[x][y] : - fill (xypath[x][y] peepholed (unitsquare shifted (x,y))) - scaled_to_grid withpen pencircle scaled 0 - withcolor chart_background_color ; - else : - fill xypath[x][y] scaled_to_grid withcolor xyfill[x][y] ; - fi ; - draw xypath[x][y] scaled_to_grid withcolor xydraw[x][y] ; - if show_con_points or show_all_points : - draw_connection_point (x, y, 0) ; - fi ; - if show_all_points : - for i=-1 upto 1 : - draw_connection_point (x, y, i) ; - endfor ; - fi ; - fi ; - endgroup ; -enddef ; - -vardef points_initialized (expr xfrom, yfrom, xto, yto, n) = - if not xyfree[xfrom][yfrom] and not xyfree[xto][yto] : - xypoint := n ; true - else : - xypoint := 0 ; false - fi -enddef ; - -def collapse_points = % this is now an mp-tool macro - % remove redundant points - n := 1 ; - for i=2 upto xypoint: - if not (xypoints[i]=xypoints[n]) : - n := n + 1 ; - xypoints[n] := xypoints[i] - fi ; - endfor ; - xypoint := n ; - % make straight lines - if xypoints[2]=xypoints[xypoint-1] : - xypoints[3] := xypoints[xypoint] ; - xypoint := 3 ; - fi ; -enddef ; - -vardef smooth_connection (expr a,b) = - sx := connection_smooth_size/grid_width ; - sy := connection_smooth_size/grid_height ; - if ypart a = ypart b : - a shifted (if xpart a >= xpart b : - fi sx,0) -% a shifted (sx*xpart unitvector(b-a),0) - else : - a shifted (0,if ypart a >= ypart b : - fi sy) -% a shifted (0,sy*ypart unitvector(b-a)) - fi -enddef ; - -vardef trim_points = - begingroup - save p, a, b, d, i ; path p ; pair d ; - p := for i=1 upto xypoint-1 : xypoints[i]-- endfor xypoints[xypoint] ; - if touchshape : - a := shape_line_width/grid_width ; - b := shape_line_width/grid_height ; - else : - a := epsilon ; - b := epsilon ; - fi ; - d := direction infinity of p ; - xypoints[xypoint] := xypoints[xypoint] shifted - if xpart d < 0 : (+a,0) ; - elseif xpart d > 0 : (-a,0) ; - elseif ypart d < 0 : (0,+b) ; - elseif ypart d > 0 : (0,-b) ; - else : origin ; - fi ; - d := direction 0 of p ; - xypoints[1] := xypoints[1] shifted - if xpart d < 0 : (-a,0) ; - elseif xpart d > 0 : (+a,0) ; - elseif ypart d < 0 : (0,-b) ; - elseif ypart d > 0 : (0,+b) ; - else : origin ; - fi ; - endgroup -enddef ; - -vardef trim_points = enddef ; - -vardef connection_path = - if reverse_connection : reverse fi (xypoints[1]-- - for i=2 upto xypoint-1 : - if smooth : - smooth_connection(xypoints[i],xypoints[i-1]) .. - controls xypoints[i] and xypoints[i] .. - smooth_connection(xypoints[i],xypoints[i+1]) -- - else : - xypoints[i]-- - fi - endfor - xypoints[xypoint]) -enddef ; - -% vardef connection_path = -% sx := connection_smooth_size/grid_width ; -% sy := connection_smooth_size/grid_height ; -% if reverse_connection : reverse fi -% (for i=1 upto xypoint-1 : xypoints[i] -- endfor xypoints[xypoint]) -% if smooth : cornered max(sx,sy) fi -% enddef ; -% -% primarydef p cornered c = -% if cycle p : -% ((point 0 of p) shifted (c*(unitvector(point 1 of p - point 0 of p))) -- -% for i=1 upto length(p) : -% (point i-1 of p) shifted (c*(unitvector(point i of p - point i-1 of p))) -- -% (point i of p) shifted (c*(unitvector(point i-1 of p - point i of p))) .. -% controls point i of p .. -% endfor cycle) -% else : -% ((point 0 of p) -- -% for i=1 upto length(p)-1 : -% (point i-1 of p) shifted (c*(unitvector(point i of p - point i-1 of p))) -- -% (point i of p) shifted (c*(unitvector(point i-1 of p - point i of p))) .. -% controls point i of p .. -% endfor -% (point length(p) of p)) -% fi -% enddef ; - -def draw_connection = - if xypoint>0 : - collapse_points ; - trim_points ; - cpath := cpath + 1 ; - cpaths[cpath] := connection_path scaled_to_grid ; - cline[cpath] := connection_line_width ; - ccolor[cpath] := connection_line_color ; - carrow[cpath] := arrowtip ; - cdash[cpath] := dashline ; - ccross[cpath] := showcrossing ; - else : - message("no connection defined") ; - fi ; - reverse_connection := false ; -enddef ; - -def flush_connections = - pair ip ; - boolean crossing ; - ahlength := connection_arrow_size ; - dash_pattern := dashpattern(on connection_dash_size off connection_dash_size ) ; - for i=1 upto cpath : - if ccross[i] : - crossing := false ; - for j=1 upto i : - %if not ((point infinity of cpaths[i] = point infinity of cpaths[j]) or - % (point 0 of cpaths[i] = point 0 of cpaths[j])) : - if not (point infinity of cpaths[i] = point infinity of cpaths[j]) : - ip := cpaths[i] intersection_point cpaths[j] ; - if intersection_found : crossing := true fi ; - fi ; - endfor ; - if crossing : - pickup pencircle scaled 2cline[i] ; - %draw cpaths[i] withcolor chart_background_color ; - path cp ; cp := cpaths[i] ; - cp := cp cutbefore point .05 length cp of cp ; - cp := cp cutafter point .95 length cp of cp ; - draw cp withcolor chart_background_color ; - fi ; - fi ; - pickup pencircle scaled cline[i] ; - if carrow[i] : - if cdash[i] : - drawarrow cpaths[i] withcolor ccolor[i] dashed dash_pattern ; - else : - drawarrow cpaths[i] withcolor ccolor[i] ; - fi ; - else : - if cdash[i] : - draw cpaths[i] withcolor ccolor[i] dashed dash_pattern ; - else : - draw cpaths[i] withcolor ccolor[i] ; - fi ; - fi ; - draw_midpoint (i) ; - endfor ; -enddef ; - -def draw_midpoint (expr n) = - begingroup - save p ; - pair p ; - p := point .5*length(cpaths[n]) of cpaths[n]; - pickup pencircle scaled 2cline[n] ; - save_text_position (p) ; - if show_mid_points : - drawdot p withcolor .7white ; - fi ; - endgroup ; -enddef ; - -boolean reverse_connection ; reverse_connection := false ; - -vardef up_on_grid (expr n) = - (xpart xypoints[n],(ypart xypoints[n]+1) div 1) -enddef ; - -vardef down_on_grid (expr n) = - (xpart xypoints[n],(ypart xypoints[n]) div 1) -enddef ; - -vardef left_on_grid (expr n) = - ((xpart xypoints[n]) div 1, ypart xypoints[n]) -enddef ; - -vardef right_on_grid (expr n) = - ((xpart xypoints[n]+1) div 1, ypart xypoints[n]) -enddef ; - -vardef x_on_grid (expr n, xfrom, xto, zfrom) = - if (xfrom=xto) and not (zfrom=0) : - if (zfrom=1) : right_on_grid(2) else : left_on_grid(2) fi - elseif xpart xypoints[1] < xpart xypoints[6] : - right_on_grid(n) - else : - left_on_grid(n) - fi -enddef ; - -vardef y_on_grid (expr n, yfrom, yto, zfrom) = - if (yfrom=yto) and not (zfrom=0) : - if (zfrom=1) : up_on_grid(2) else : down_on_grid(2) fi - elseif ypart xypoints[1] < ypart xypoints[6] : - up_on_grid(n) - else : - down_on_grid(n) - fi -enddef ; - -vardef xy_on_grid (expr n, m) = - (xpart xypoints[n], ypart xypoints[m]) -enddef ; - -vardef down_to_grid (expr a,b) = - (xpart xypoints[a], - ypart xypoints[if ypart xypoints[a]ypart xypoints[b]:a else:b fi]) -enddef ; - -vardef left_to_grid (expr a,b) = - (xpart xypoints[if xpart xypoints[a]xpart xypoints[b]:a else:b fi], - ypart xypoints[a]) -enddef ; - -% vardef boundingboxfraction(expr p, f) = -% ((boundingbox p) enlarged (-f*bbwidth(p),-f*bbheight(p))) -% enddef ; - -vardef valid_connection (expr xfrom, yfrom, xto, yto) = - begingroup ; - save ok, vc, pp ; - boolean ok ; - % check for slanted lines - ok := true ; - for i=1 upto xypoint-1 : - if not ((xpart xypoints[i]=xpart xypoints[i+1]) or - (ypart xypoints[i]=ypart xypoints[i+1])) : ok := false ; - fi ; - endfor ; - if not ok : - %message("slanted"); - false - elseif forcevalid : - %message("force"); - true - elseif (xfrom=xto) and (yfrom=yto) : - %message("self"); - false - else : - % check for crossing shapes - pair vc ; - path pp ; - - pair xyfirst, xylast ; - xyfirst := xypoints[1] ; - xylast := xypoints[xypoint] ; - trim_points ; - pp := for i=1 upto xypoint-1 : xypoints[i]-- endfor xypoints[xypoint] ; - xypoints[1] := xyfirst ; - xypoints[xypoint] := xylast ; - - for i=1 upto max_x : - for j=1 upto max_y : % was bug: xfrom,yto - if not ( ( (i,j)=(xfrom,yfrom) ) or ( (i,j)=(xto,yto) ) ) : - if not xyfree[i][j] : - vc := pp intersection_point xypath[i][j] ; - if intersection_found : ok := false fi ; - fi ; - fi ; - endfor ; - endfor ; - %if not ok: message("crossing") ; fi ; - ok - fi - endgroup -enddef ; - -def connect_top_bottom (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = - yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; - if points_initialized(xfrom,yfrom,xto,yto,6) : - xypoints[1] := xy_top(xfrom,yfrom,zfrom,true) ; - xypoints[6] := xy_bottom(xto,yto,zto,true) ; - xypoints[2] := up_on_grid(1) ; - xypoints[5] := down_on_grid(6) ; - xypoints[3] := up_to_grid(2,5) ; - xypoints[4] := up_to_grid(2,5) ; - if not valid_connection(xfrom,yfrom,xto,yto) : - xypoints[3] := x_on_grid(2,xfrom,xto,zfrom) ; - xypoints[4] := xy_on_grid(3,5) ; - fi ; - %%%% begin experiment - xypoints[3] := xypoints[3] shifted (dsp_x,0) ; - xypoints[4] := xypoints[4] shifted (dsp_x,0) ; - if dsp_y>0 : - xypoints[2] := xypoints[2] shifted (0,dsp_y) ; - xypoints[3] := xypoints[3] shifted (0,dsp_y) ; - elseif dsp_y<0 : - xypoints[4] := xypoints[4] shifted (0,dsp_y) ; - xypoints[5] := xypoints[5] shifted (0,dsp_y) ; - fi - %%%% end experiment - draw_connection ; - fi ; -enddef ; - -def connect_left_right (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = - yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; - if points_initialized(xfrom,yfrom,xto,yto,6) : - xypoints[1] := xy_left(xfrom,yfrom,zfrom,true) ; - xypoints[6] := xy_right(xto,yto,zto,true) ; - xypoints[2] := left_on_grid(1) ; - xypoints[5] := right_on_grid(6) ; - xypoints[3] := left_to_grid(2,5) ; - xypoints[4] := left_to_grid(2,5) ; - if not valid_connection(xfrom,yfrom,xto,yto) : - xypoints[3] := y_on_grid(2,yfrom,yto,zfrom) ; - xypoints[4] := xy_on_grid(5,3) ; - fi ; - draw_connection ; - fi ; -enddef ; - -def connect_left_top (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = - yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; - if points_initialized(xfrom,yfrom,xto,yto,5) : - xypoints[1] := xy_left(xfrom,yfrom,zfrom,true) ; - xypoints[5] := xy_top(xto,yto,zto,true) ; - xypoints[2] := left_on_grid(1) ; - xypoints[4] := up_on_grid(5) ; - xypoints[3] := left_to_grid(2,5) ; - if not valid_connection(xfrom,yfrom,xto,yto) : - xypoints[3] := xy_on_grid(2,4) ; - fi ; - draw_connection ; - fi ; -enddef ; - -def connect_left_bottom (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = - yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; - if points_initialized(xfrom,yfrom,xto,yto,5) : - xypoints[1] := xy_left(xfrom,yfrom,zfrom,true) ; - xypoints[5] := xy_bottom(xto,yto,zto,true) ; - xypoints[2] := left_on_grid(1) ; - xypoints[4] := down_on_grid(5) ; - xypoints[3] := left_to_grid(2,5) ; - if not valid_connection(xfrom,yfrom,xto,yto) : - xypoints[3] := xy_on_grid(2,4) ; - fi ; - draw_connection ; - fi ; -enddef ; - -def connect_right_top (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = - yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; - if points_initialized(xfrom,yfrom,xto,yto,5) : - xypoints[1] := xy_right(xfrom,yfrom,zfrom,true) ; - xypoints[5] := xy_top(xto,yto,zto,true) ; - xypoints[2] := right_on_grid(1) ; - xypoints[4] := up_on_grid(5) ; - xypoints[3] := right_to_grid(2,5) ; - if not valid_connection(xfrom,yfrom,xto,yto) : - xypoints[3] := xy_on_grid(2,4) ; - fi ; - draw_connection ; - fi ; -enddef ; - -def connect_right_bottom (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = - yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; - if points_initialized(xfrom,yfrom,xto,yto,5) : - xypoints[1] := xy_right(xfrom,yfrom,zfrom,true) ; - xypoints[5] := xy_bottom(xto,yto,zto,true) ; - xypoints[2] := right_on_grid(1) ; - xypoints[4] := down_on_grid(5) ; - xypoints[3] := right_to_grid(2,5) ; - if not valid_connection(xfrom,yfrom,xto,yto) : - xypoints[3] := xy_on_grid(2,4) ; - fi ; - %%%% begin experiment - xypoints[2] := xypoints[2] shifted (dsp_x,0) ; - xypoints[3] := xypoints[3] shifted (dsp_x,0) ; - if dsp_y>0 : - xypoints[3] := xypoints[3] shifted (0,-dsp_y) ; - xypoints[4] := xypoints[4] shifted (0,-dsp_y) ; - elseif dsp_y<0 : - xypoints[3] := xypoints[3] shifted (0,dsp_y) ; - xypoints[4] := xypoints[4] shifted (0,dsp_y) ; - fi - %%%% end experiment - draw_connection ; - fi ; -enddef ; - -def connect_left_left (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = - yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; - if points_initialized(xfrom,yfrom,xto,yto,6) : - xypoints[1] := xy_left(xfrom,yfrom,zfrom,true) ; - xypoints[6] := xy_left(xto,yto,zto,true) ; - xypoints[2] := left_on_grid(1) ; - xypoints[5] := left_on_grid(6) ; - xypoints[3] := left_to_grid(2,5) ; - xypoints[4] := left_to_grid(5,2) ; - if not valid_connection(xfrom,yfrom,xto,yto) : - xypoints[3] := y_on_grid(2,yfrom,yto,zfrom) ; - xypoints[4] := xy_on_grid(5,3) ; - fi ; - draw_connection ; - fi ; -enddef ; - -def connect_right_right (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = - yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; - if points_initialized(xfrom,yfrom,xto,yto,6) : - xypoints[1] := xy_right(xfrom,yfrom,zfrom,true) ; - xypoints[6] := xy_right(xto,yto,zto,true) ; - xypoints[2] := right_on_grid(1) ; - xypoints[5] := right_on_grid(6) ; - xypoints[3] := right_to_grid(2,5) ; - xypoints[4] := right_to_grid(5,2) ; - if not valid_connection(xfrom,yfrom,xto,yto) : - xypoints[3] := y_on_grid(2,yfrom,yto,zfrom) ; - xypoints[4] := xy_on_grid(5,3) ; - fi ; - draw_connection ; - fi ; -enddef ; - -def connect_top_top (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = - yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; - if points_initialized(xfrom,yfrom,xto,yto,6) : - xypoints[1] := xy_top(xfrom,yfrom,zfrom,true) ; - xypoints[6] := xy_top(xto,yto,zto,true) ; - xypoints[2] := up_on_grid(1) ; - xypoints[5] := up_on_grid(6) ; - xypoints[3] := up_to_grid(2,5) ; - xypoints[4] := up_to_grid(5,2) ; - if not valid_connection(xfrom,yfrom,xto,yto) : - xypoints[3] := x_on_grid(2,xfrom,xto,zfrom) ; - xypoints[4] := xy_on_grid(3,5) ; - fi ; - draw_connection ; - fi ; -enddef ; - -def connect_bottom_bottom (expr xfrom,yyfrom,zfrom) (expr xto,yyto,zto) = - yfrom := y_pos(yyfrom) ; yto := y_pos(yyto) ; - if points_initialized(xfrom,yfrom,xto,yto,6) : - xypoints[1] := xy_bottom(xfrom,yfrom,zfrom,true) ; - xypoints[6] := xy_bottom(xto,yto,zto,true) ; - xypoints[2] := down_on_grid(1) ; - xypoints[5] := down_on_grid(6) ; - xypoints[3] := down_to_grid(2,5) ; - xypoints[4] := down_to_grid(5,2) ; - if not valid_connection(xfrom,yfrom,xto,yto) : - xypoints[3] := x_on_grid(2,xfrom,xto,zfrom) ; - xypoints[4] := xy_on_grid(3,5) ; - fi ; - %%%% begin experiment - xypoints[3] := xypoints[3] shifted (dsp_x,0) ; - xypoints[4] := xypoints[4] shifted (dsp_x) ; - if dsp_y<0 : - xypoints[2] := xypoints[2] shifted (0,-dsp_y) ; - xypoints[3] := xypoints[3] shifted (0,-dsp_y) ; - elseif dsp_y>0 : - xypoints[4] := xypoints[4] shifted (0,dsp_y) ; - xypoints[5] := xypoints[5] shifted (0,dsp_y) ; - fi - %%%% end experiment - draw_connection ; - fi ; -enddef ; - -def connect_bottom_top (expr xfrom,yfrom,zfrom) (expr xto,yto,zto) = - reverse_connection := true ; - connect_top_bottom (xto,yto,zto) (xfrom,yfrom,zfrom) ; -enddef ; - -def connect_right_left (expr xfrom,yfrom,zfrom) (expr xto,yto,zto) = - reverse_connection := true ; - connect_left_right (xto,yto,zto) (xfrom,yfrom,zfrom) ; -enddef ; - -def connect_top_left (expr xfrom,yfrom,zfrom) (expr xto,yto,zto) = - reverse_connection := true ; - connect_left_top (xto,yto,zto) (xfrom,yfrom,zfrom) ; -enddef ; - -def connect_bottom_left (expr xfrom,yfrom,zfrom) (expr xto,yto,zto) = - reverse_connection := true ; - connect_left_bottom (xto,yto,zto) (xfrom,yfrom,zfrom) ; -enddef ; - -def connect_top_right (expr xfrom,yfrom,zfrom) (expr xto,yto,zto) = - reverse_connection := true ; - connect_right_top (xto,yto,zto) (xfrom,yfrom,zfrom) ; -enddef ; - -def connect_bottom_right (expr xfrom,yfrom,zfrom) (expr xto,yto,zto) = - reverse_connection := true ; - connect_right_bottom (xto,yto,zto) (xfrom,yfrom,zfrom) ; -enddef ; - -def draw_test_shape (expr x, y) = - draw_shape(x,y,fullcircle, .7, .7) ; -enddef ; - -def draw_test_shapes = - for i=1 upto max_x : - for j=1 upto max_y : - draw_test_shape(i,j) ; - endfor ; - endfor ; -enddef; - -def draw_test_area = - pickup pencircle scaled .5shape_line_width ; - draw (unitsquare xscaled max_x yscaled max_y shifted (1,1)) - scaled_to_grid withcolor blue ; -enddef ; - -def show_connection (expr n, m) = - - begin_chart(100+n,6,6) ; - - draw_test_area ; - - smooth := true ; - arrowtip := true ; - dashline := true ; - - draw_test_shape(2,2) ; draw_test_shape(4,5) ; - draw_test_shape(3,3) ; draw_test_shape(5,1) ; - draw_test_shape(2,5) ; draw_test_shape(1,3) ; - draw_test_shape(6,2) ; draw_test_shape(4,6) ; - - if (m=1) : - connect_top_bottom (2,2,0) (4,5,0) ; - connect_top_bottom (3,3,0) (5,1,0) ; - connect_top_bottom (2,5,0) (1,3,0) ; - connect_top_bottom (6,2,0) (4,6,0) ; - elseif (m=2) : - connect_top_top (2,2,0) (4,5,0) ; - connect_top_top (3,3,0) (5,1,0) ; - connect_top_top (2,5,0) (1,3,0) ; - connect_top_top (6,2,0) (4,6,0) ; - elseif (m=3) : - connect_bottom_bottom (2,2,0) (4,5,0) ; - connect_bottom_bottom (3,3,0) (5,1,0) ; - connect_bottom_bottom (2,5,0) (1,3,0) ; - connect_bottom_bottom (6,2,0) (4,6,0) ; - elseif (m=4) : - connect_left_right (2,2,0) (4,5,0) ; - connect_left_right (3,3,0) (5,1,0) ; - connect_left_right (2,5,0) (1,3,0) ; - connect_left_right (6,2,0) (4,6,0) ; - elseif (m=5) : - connect_left_left (2,2,0) (4,5,0) ; - connect_left_left (3,3,0) (5,1,0) ; - connect_left_left (2,5,0) (1,3,0) ; - connect_left_left (6,2,0) (4,6,0) ; - elseif (m=6) : - connect_right_right (2,2,0) (4,5,0) ; - connect_right_right (3,3,0) (5,1,0) ; - connect_right_right (2,5,0) (1,3,0) ; - connect_right_right (6,2,0) (4,6,0) ; - elseif (m=7) : - connect_left_top (2,2,0) (4,5,0) ; - connect_left_top (3,3,0) (5,1,0) ; - connect_left_top (2,5,0) (1,3,0) ; - connect_left_top (6,2,0) (4,6,0) ; - elseif (m=8) : - connect_left_bottom (2,2,0) (4,5,0) ; - connect_left_bottom (3,3,0) (5,1,0) ; - connect_left_bottom (2,5,0) (1,3,0) ; - connect_left_bottom (6,2,0) (4,6,0) ; - elseif (m=9) : - connect_right_top (2,2,0) (4,5,0) ; - connect_right_top (3,3,0) (5,1,0) ; - connect_right_top (2,5,0) (1,3,0) ; - connect_right_top (6,2,0) (4,6,0) ; - else : - connect_right_bottom (2,2,0) (4,5,0) ; - connect_right_bottom (3,3,0) (5,1,0) ; - connect_right_bottom (2,5,0) (1,3,0) ; - connect_right_bottom (6,2,0) (4,6,0) ; - fi ; - - end_chart ; - -enddef ; - -def show_connections = - for f=1 upto 10 : - show_connection(f,f) ; - endfor ; -enddef ; - -%D charts - -def clip_chart (expr minx, miny, maxx, maxy) = - cmin_x := minx ; - cmax_x := maxx ; - cmin_y := miny ; - cmax_y := maxy ; -enddef ; - -def begin_chart (expr n, maxx, maxy) = - new_chart ; - chart_figure := n ; - chart_scale := 1 ; - if chart_figure>0: beginfig(chart_figure) ; fi ; - initialize_grid (maxx, maxy) ; - bboxmargin := 0 ; - cmin_x := 1 ; - cmax_x := maxx ; - cmin_y := 1 ; - cmax_y := maxy ; -enddef ; - -def end_chart = - flush_shapes ; - flush_connections ; - cmin_x := cmin_x ; - cmax_x := cmin_x+cmax_x ; - cmin_y := cmin_y-1 ; - cmax_y := cmin_y+cmax_y ; - if reverse_y : - cmin_y := y_pos(cmin_y) ; - cmax_y := y_pos(cmax_y) ; - fi ; - path p ; - p := (((cmin_x,cmin_y)--(cmax_x,cmin_y)-- - (cmax_x,cmax_y)--(cmin_x,cmax_y)--cycle)) - scaled_to_grid ; - %draw p withcolor red ; - p := p enlarged chart_offset ; - clip currentpicture to p ; - setbounds currentpicture to p ; - savedata - "\MPclippath{" & - decimal xpart llcorner p & "}{" & - decimal ypart llcorner p & "}{" & - decimal xpart urcorner p & "}{" & - decimal ypart urcorner p & "}" ; - savedata - "\MPareapath{" & - decimal (xpart llcorner p + 2chart_offset) & "}{" & - decimal (ypart llcorner p + 2chart_offset) & "}{" & - decimal (xpart urcorner p - 2chart_offset) & "}{" & - decimal (ypart urcorner p - 2chart_offset) & "}" ; - currentpicture := currentpicture scaled chart_scale ; - if chart_figure>0: endfig ; fi ; -enddef ; - -def new_shape (expr x, y, n) = - if known n : - if (x>0) and (x<=max_x) and (y>0) and (y<=max_y) : - sx := shape_width/grid_width ; - sy := shape_height/grid_height ; - draw_shape(x,y,some_shape_path(n), sx, sy) ; - else : - message ("shape outside grid ignored") ; - fi ; - else - message ("shape not known" ) ; - fi ; -enddef ; - -def begin_sub_chart = - begingroup ; - save shape_line_width , connection_line_width ; - save shape_line_color, shape_fill_color, connection_line_color ; - color shape_line_color, shape_fill_color, connection_line_color ; - save smooth, arrowtip, dashline, peepshape ; - boolean smooth, arrowtip, dashline, peepshape ; -enddef ; - -def end_sub_chart = - endgroup ; -enddef ; - -%D done - -endinput ; - -%D testing - -show_shapes(100) ; - -end - -%D more testing - -show_connections ; - -begin_chart (1,4,5) ; - %clip_chart(1,1,1,2) ; - new_shape (1,1,31) ; - new_shape (1,2,3) ; - new_shape (4,4,5) ; - connect_top_left (1,1,0) (4,4,0) ; - connect_bottom_top (1,2,0) (4,4,0) ; - connect_left_right (1,2,0) (1,1,0) ; -end_chart ; - -end diff --git a/metapost/context/mp-core.mp b/metapost/context/mp-core.mp deleted file mode 100644 index 5f1341a69..000000000 --- a/metapost/context/mp-core.mp +++ /dev/null @@ -1,1116 +0,0 @@ -%D \module -%D [ file=mp-core.mp, -%D version=2000.something, % 1999.08.12, -%D title=\CONTEXT\ \METAPOST\ graphics, -%D subtitle=core interfacing, -%D author=Hans Hagen, -%D date=\currentdate, -%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] -%C -%C This module is part of the \CONTEXT\ macro||package and is -%C therefore copyrighted by \PRAGMA. See licen-en.pdf for -%C details. - -if unknown context_tool : input mp-tool ; fi ; -if known context_core : endinput ; fi ; - -boolean context_core ; context_core := true ; - -pair lxy[], rxy[], cxy[], llxy[], lrxy[], ulxy[], urxy[] ; -path pxy[] ; -numeric hxy[], wxy[], dxy[], nxy[] ; - -def box_found (expr n,x,y,w,h,d) = - not ((x=0) and (y=0) and (w=0) and (h=0) and (d=0)) -enddef ; - -def initialize_box_pos (expr pos,n,x,y,w,h,d) = - pair lxy, rxy, cxy, llxy, lrxy, ulxy, urxy ; - path pxy ; numeric hxy, wxy, dxy, nxy; - lxy := (x,y) ; - llxy := (x,y-d) ; - lrxy := (x+w,y-d) ; - urxy := (x+w,y+h) ; - ulxy := (x,y+h) ; - wxy := w ; - hxy := h ; - dxy := d ; - rxy := lxy shifted (wxy,0) ; - pxy := llxy--lrxy--urxy--ulxy--cycle ; - cxy := center pxy ; - nxy := n ; - freeze_box(pos) ; -enddef ; - -def freeze_box (expr pos) = - lxy[pos] := lxy ; - llxy[pos] := llxy ; - lrxy[pos] := lrxy ; - urxy[pos] := urxy ; - ulxy[pos] := ulxy ; - wxy[pos] := wxy ; - hxy[pos] := hxy ; - dxy[pos] := dxy ; - rxy[pos] := rxy ; - pxy[pos] := pxy ; - cxy[pos] := cxy ; - nxy[pos] := nxy ; -enddef ; - -def initialize_box (expr n,x,y,w,h,d) = - - numeric bpos ; bpos := 0 ; initialize_box_pos(bpos,n,x,y,w,h,d) ; - -enddef ; - -def initialize_area (expr fn,fx,fy,fw,fh,fd, - tn,tx,ty,tw,th,td) = - - numeric fpos ; fpos := 1 ; initialize_box_pos(fpos,fn,fx,fy,fw,fh,fd) ; - numeric tpos ; tpos := 2 ; initialize_box_pos(tpos,tn,tx,ty,tw,th,td) ; - - do_initialize_area (fpos, tpos) ; - -enddef ; - -def do_initialize_area (expr fpos, tpos) = - lxy := lxy[fpos] ; - llxy := (xpart llxy[fpos], ypart llxy[tpos]) ; - lrxy := lrxy[tpos] ; - urxy := (xpart urxy[tpos], ypart urxy[fpos]) ; - ulxy := ulxy[fpos] ; - wxy := xpart lrxy - xpart llxy ; - hxy := hxy[fpos] ; - dxy := dxy[tpos] ; - rxy := lxy shifted (wxy,0) ; - pxy := llxy--lrxy--urxy--ulxy--cycle ; - cxy := center pxy ; -enddef ; - -def set_par_line_height (expr ph, pd) = - par_strut_height := - if ph>0 : ph elseif StrutHeight>0 : StrutHeight else : 8pt fi ; - par_strut_depth := - if pd>0 : pd elseif StrutDepth >0 : StrutDepth else : 3pt fi ; - par_line_height := - par_strut_height + par_strut_depth ; -enddef ; - -def initialize_par (expr fn,fx,fy,fw,fh,fd, - tn,tx,ty,tw,th,td, - mn,mx,my,mw,mh,md, - pn,px,py,pw,ph,pd, - rw,rl,rr,rh,ra,ri) = - - numeric fpos ; fpos := 1 ; initialize_box_pos(fpos,fn,fx,fy,fw,fh,fd) ; - numeric tpos ; tpos := 2 ; initialize_box_pos(tpos,tn,tx,ty,tw,th,td) ; - numeric mpos ; mpos := 3 ; initialize_box_pos(mpos,mn,mx,my,mw,mh,md) ; - numeric ppos ; ppos := 4 ; initialize_box_pos(ppos,pn,px,py,pw,ph,pd) ; - - numeric par_strut_height, par_strut_depth, par_line_height ; - - set_par_line_height (ph, pd) ; - - do_initialize_area (fpos, tpos) ; - do_initialize_par (fpos, tpos, mpos, ppos, rw,rl,rr,rh,ra,ri) ; - -enddef ; - -def initialize_area_par (expr fn,fx,fy,fw,fh,fd, - tn,tx,ty,tw,th,td, - wn,wx,wy,ww,wh,wd) = - - numeric fpos ; fpos := 1 ; initialize_box_pos(fpos,fn,fx,fy,fw,fh,fd) ; - numeric tpos ; tpos := 2 ; initialize_box_pos(tpos,tn,tx,ty,tw,th,td) ; - numeric wpos ; wpos := 3 ; initialize_box_pos(wpos,wn,wx,wy,ww,wh,wd) ; - - numeric par_strut_height, par_strut_depth, par_line_height ; - - set_par_line_height (wh, wd) ; - - numeric ffpos ; ffpos := 4 ; initialize_box_pos(ffpos,wn,wx,fy,0,wh,wd) ; - numeric ttpos ; ttpos := 5 ; initialize_box_pos(ttpos,wn,wx+ww,ty,0,wh,wd) ; - - do_initialize_area (ffpos, ttpos) ; - - numeric mpos ; mpos := 6 ; freeze_box(mpos) ; - -% do_initialize_area (fpos, tpos) ; - do_initialize_par (fpos, tpos, mpos, ffpos, 0,0,0,0,0,0) ; - -enddef ; - -def do_initialize_par (expr fpos, tpos, mpos, ppos, rw,rl,rr,rh,ra,ri) = - - pair lref, rref, pref, lhref, rhref ; - - % clip the page area to the left and right skips - - llxy[mpos] := llxy[mpos] shifted (+rl,0) ; - lrxy[mpos] := lrxy[mpos] shifted (-rr,0) ; - urxy[mpos] := urxy[mpos] shifted (-rr,0) ; - ulxy[mpos] := ulxy[mpos] shifted (+rl,0) ; - - % fixate the leftskip, rightskip and hanging indentation - - lref := (xpart llxy[mpos],ypart ulxy[ppos]) ; lhref := lref shifted (rh,0) ; - rref := (xpart lrxy[mpos],ypart urxy[ppos]) ; rhref := rref shifted (rh,0) ; - - pref := lxy[ppos] ; - - if nxy[tpos] > nxy[fpos] : - if nxy[fpos] = nxy[mpos] : - % first of multiple pages - llxy[tpos] := llxy[mpos] ; - lrxy[tpos] := lrxy[mpos] ; - urxy[tpos] := lrxy[mpos] shifted (0,par_line_height) ; - ulxy[tpos] := llxy[mpos] shifted (0,par_line_height) ; - boxgriddirection := down ; - elseif nxy[tpos] = nxy[mpos] : - % last of multiple pages - llxy[fpos] := ulxy[mpos] shifted (0,-par_line_height) ; - lrxy[fpos] := urxy[mpos] shifted (0,-par_line_height) ; - urxy[fpos] := urxy[mpos] ; - ulxy[fpos] := ulxy[mpos] ; - boxgriddirection := up ; - else : - % middle of multiple pages - llxy[fpos] := ulxy[mpos] shifted (0,-par_line_height) ; - lrxy[fpos] := urxy[mpos] shifted (0,-par_line_height) ; - urxy[fpos] := urxy[mpos] ; - ulxy[fpos] := ulxy[mpos] ; - llxy[tpos] := llxy[mpos] ; - lrxy[tpos] := lrxy[mpos] ; - urxy[tpos] := lrxy[mpos] shifted (0,par_line_height) ; - ulxy[tpos] := llxy[mpos] shifted (0,par_line_height) ; - boxgriddirection := up ; - fi ; - else : - % just one page - boxgriddirection := up ; - fi ; - - path txy, bxy, pxy, mxy ; - - txy := originpath ; % top - bxy := originpath ; % bottom - pxy := originpath ; % composed - - boolean lefthang, righthang, somehang ; - - % we only hang on the first of a multiple page background - - if nxy[mpos] > nxy[fpos] : - lefthang := righthang := somehang := false ; - else : - lefthang := (rh>0) ; righthang := (rh<0) ; somehang := false ; - fi ; - - if lefthang : - mxy := boundingbox (lref -- lref shifted (rh,ra*par_line_height)) ; - elseif righthang : - mxy := boundingbox (rref -- rref shifted (rh,ra*par_line_height)) ; - else : - mxy := originpath ; - fi ; - - if round(ypart llxy[fpos]) = round(ypart llxy[tpos]) : - - % We have a one-liner. Watch how er use the bottom pos for - % determining the height. - - llxy[fpos] := (xpart llxy[fpos], ypart llxy[tpos]) ; - ulxy[fpos] := (xpart ulxy[fpos], ypart ulxy[tpos]) ; - - else : - - % We have a multi-liner. For convenience we now correct the - % begin and end points for indentation. - - if lefthang and (round(ypart llxy[tpos]) >= round(ypart lrcorner mxy)) : - llxy[tpos] := (xpart lhref, ypart llxy[tpos]) ; - ulxy[tpos] := (xpart lhref, ypart ulxy[tpos]) ; - else : - llxy[tpos] := (xpart lref, ypart llxy[tpos]) ; - ulxy[tpos] := (xpart lref, ypart ulxy[tpos]) ; - fi ; - - if righthang and (round(ypart lrxy[fpos]) >= round(ypart llcorner mxy)) : - lrxy[fpos] := (xpart rhref, ypart lrxy[fpos]) ; - urxy[fpos] := (xpart rhref, ypart urxy[fpos]) ; - else : - lrxy[fpos] := (xpart rref, ypart lrxy[fpos]) ; - urxy[fpos] := (xpart rref, ypart urxy[fpos]) ; - fi ; - - fi ; - - somehang := (ypart ulxy[fpos]>ypart llcorner mxy) and - (ypart llxy[tpos]0 : - left_skip := rl + xpart llxy[wpos] - xpart llxy[ppos] ; - right_skip := rw - left_skip - ww ; - else : - left_skip := rl ; - right_skip := rr ; - fi ; - - path multipar, multipars[] ; - numeric multiref, multirefs[] ; - numeric multiloc, multilocs[] ; % 1=begin 2=between 3=end - - numeric multi_par_pages ; multi_par_pages := nxy[tpos]-nxy[fpos]+1 ; - - ii := 0 ; nn := NOfTextAreas+1 ; nofmultipars := 0 ; - - vardef snapped_multi_pos (expr p) = - if snap_multi_par_tops : - if abs(ypart p - ypart ulcorner multipar) < par_line_height : - (xpart p,ypart ulcorner multipar) - else : - p - fi - else : - p - fi - enddef ; - - % def set_multipar (expr i) = - % ((TextAreas[i] leftenlarged -left_skip) rightenlarged -right_skip) - % enddef ; - - vardef set_multipar (expr i) = - ( (TextAreas[i] leftenlarged -left_skip) rightenlarged (-right_skip - if auto_multi_par_hsize : + rw - bbwidth(TextAreas[i]) fi) ) - enddef ; - - vardef top_multi_par(expr p) = - (round(estimated_par_lines(bbheight(p)*par_line_height))=round(bbheight(p))) - enddef ; - - vardef multi_par_tsc(expr p) = - if top_multi_par(p) : TopSkipCorrection else : 0 fi - enddef ; - - vardef estimated_par_lines (expr h) = - round(h/par_line_height) - enddef ; - - vardef estimated_multi_par_height (expr n, t) = - if round(par_line_height)=0 : - 0 - else : - save ok, h ; boolean ok ; - numeric h ; h := 0 ; - ok := false ; - if (nxy[fpos]=RealPageNumber-1) : - for i := 1 upto NOfSavedTextAreas : - if (InsideSavedTextArea(i,par_start_pos)) : - ok := true ; - h := h + estimated_par_lines(ypart ulxy[fpos] - - ypart llcorner SavedTextAreas[i]) ; - elseif ok : - h := h + estimated_par_lines(bbheight(SavedTextAreas[i])) ; - fi ; - endfor ; - fi ; - if ok : - for i := 1 upto n-1 : - h := h + estimated_par_lines(bbheight(TextAreas[i])) ; - endfor ; - else : - % already: ok := false ; - for i := 1 upto n-1 : - if (InsideTextArea(i,par_start_pos)) : - ok := true ; - h := h + estimated_par_lines(ypart ulxy[fpos] - ypart llcorner TextAreas[i]) ; - elseif ok : - h := h + estimated_par_lines(bbheight(TextAreas[i])) ; - fi ; - endfor ; - fi ; - h - fi - enddef ; - - vardef left_top_hang (expr same_area) = - -par_hang_after := ra + estimated_par_lines(py-fy) ; - - if (par_hang_indent>0) and (par_hang_after<0) and obey_multi_par_hang : - pair _ul_ ; _ul_ := (xpart ulcorner multipar, ypart snapped_multi_pos(ulxy[fpos])); - pair _pa_ ; _pa_ := _ul_ shifted (0,par_hang_after*par_line_height) ; - _pa_ := (xpart _pa_,max(ypart _pa_,ypart llcorner multipar)) ; - if same_area : - _pa_ := (xpart _pa_,max(ypart _pa_,ypart llxy[tpos])) ; - fi ; -% vervalt: - if obey_multi_par_more and (round(par_line_height)>0) : - par_hang_after := min(0,round(par_hang_after + - (ypart urxy[fpos]-ypart _pa_)/par_line_height)) ; - fi ; - (xpart _ul_ + par_hang_indent, ypart lrxy[fpos]) -- - (xpart _ul_ + par_hang_indent, ypart _pa_) -- - (xpart ulcorner multipar, ypart _pa_) - else : - (xpart ulcorner multipar, ypart lrxy[fpos]) - fi - enddef ; - - vardef right_top_hang (expr same_area) = - -par_hang_after := ra - estimated_par_lines(py-fy) ; - - if (par_hang_indent<0) and (par_hang_after<0) and obey_multi_par_hang : - pair _ur_ ; _ur_ := (xpart urcorner multipar, ypart snapped_multi_pos(urxy[fpos])) ; - pair _pa_ ; _pa_ := _ur_ shifted (0,par_hang_after*par_line_height) ; - _pa_ := (xpart _pa_,max(ypart _pa_ -TopSkipCorrection,ypart llcorner multipar)) ; - if same_area : - _pa_ := (xpart _pa_,max(ypart _pa_ -TopSkipCorrection,ypart snapped_multi_pos(ulxy[tpos]))) ; - fi ; - if obey_multi_par_more and (round(par_line_height)>0) : - par_hang_after := min(0,round(par_hang_after + - (ypart urxy[fpos]-ypart _pa_)/par_line_height)) ; - fi ; - (xpart urcorner multipar, ypart _pa_) -- - (xpart _ur_ + par_hang_indent, ypart _pa_) -- - (xpart _ur_ + par_hang_indent, ypart snapped_multi_pos(urxy[fpos])) - else : - (xpart urcorner multipar, ypart snapped_multi_pos(urxy[fpos])) - fi - enddef ; - - vardef x_left_top_hang (expr i, t) = - par_hang_after := min(0,ra + estimated_multi_par_height(i,t)) ; - if (par_hang_indent>0) and (par_hang_after<0) : - pair _ul_ ; _ul_ := ulcorner multipar ; - pair _pa_ ; _pa_ := _ul_ shifted (0,par_hang_after*par_line_height) ; - _pa_ := (xpart _pa_,max(ypart _pa_,ypart llcorner multipar)) ; - -if t : - _pa_ := (xpart _pa_,max(ypart _pa_,ypart llxy[tpos])); -fi ; -if abs(ypart _pa_-ypart llxy[tpos])0) and (par_hang_after>0) and obey_multi_par_hang : - _ll_ := (xpart ulcorner multipar, ypart snapped_multi_pos(ulxy[fpos])) ; - _pa_ := _ll_ shifted (0,-par_hang_after*par_line_height) ; - _pa_ := (xpart _pa_,max(ypart _pa_,ypart llcorner multipar)) ; - if same_area : - _pa_ := (xpart _pa_,max(ypart _pa_,ypart _sa_)) ; - fi ; - if obey_multi_par_more and (round(par_line_height)>0) : - par_hang_after := max(0,round(par_hang_after - - (ypart urxy[fpos]-ypart _pa_)/par_line_height)) ; - fi ; - _pa_ -- - (xpart _pa_ + par_hang_indent,ypart _pa_) -- - (xpart _pa_ + par_hang_indent,ypart _sa_) - else : - (xpart llcorner multipar, ypart _sa_) - fi - enddef ; - - vardef right_bottom_hang (expr same_area) = - pair _lr_, _sa_, _pa_ ; - _sa_ := if same_area : snapped_multi_pos(ulxy[tpos]) else : lrcorner multipar fi ; - if (par_hang_indent<0) and (par_hang_after>0) and obey_multi_par_hang : - _lr_ := (xpart urcorner multipar, ypart snapped_multi_pos(urxy[fpos])) ; - _pa_ := _lr_ shifted (0,-par_hang_after*par_line_height) ; - _pa_ := (xpart _pa_,max(ypart _pa_,ypart lrcorner multipar)) ; - if same_area : - _pa_ := (xpart _pa_,max(ypart _pa_,ypart snapped_multi_pos(ulxy[tpos]))) ; - fi ; - if obey_multi_par_more and (round(par_line_height)>0) : - par_hang_after := max(0,round(par_hang_after - - (ypart urxy[fpos]-ypart _pa_)/par_line_height)) ; - fi ; - (xpart _pa_ + par_hang_indent,ypart _sa_) -- - (xpart _pa_ + par_hang_indent,ypart _pa_) -- - _pa_ - else : - (xpart lrcorner multipar, ypart _sa_) - fi - enddef ; - - vardef x_left_bottom_hang (expr i, t) = - pair _ll_, _sa_, _pa_ ; -if t : - _sa_ := llxy[tpos] ; -else : - _sa_ := llcorner multipar ; -fi ; - if (par_hang_indent>0) and (ra>0) : - par_hang_after := max(0,ra - estimated_multi_par_height(i,t)) ; - _ll_ := ulcorner multipar ; - _pa_ := _ll_ shifted (0,-par_hang_after*par_line_height) ; - _pa_ := (xpart _pa_,max(ypart _pa_,ypart llcorner multipar)) ; - _pa_ := (xpart _pa_,max(ypart _pa_,ypart _sa_)) ; - % we need to compensate for topskip enlarged areas - if abs(ypart _pa_ - ypart _sa_) > par_line_height : - (xpart _pa_ + par_hang_indent,ypart _sa_) -- - (xpart _pa_ + par_hang_indent,ypart _pa_) -- - fi - _pa_ - else : - (xpart llcorner multipar, ypart _sa_) - fi - enddef ; - - vardef x_right_bottom_hang (expr i, t) = - pair _lr_, _sa_, _pa_ ; -if t : - _sa_ := snapped_multi_pos(ulxy[tpos]) ; -else : - _sa_ := llcorner multipar ; -fi ; - if (par_hang_indent<0) and (ra>0) : - par_hang_after := max(0,ra - estimated_multi_par_height(i, t)) ; - _lr_ := urcorner multipar ; - _pa_ := _lr_ shifted (0,-par_hang_after*par_line_height) ; - _pa_ := (xpart _pa_,max(ypart _pa_,ypart lrcorner multipar)) ; - _pa_ := (xpart _pa_,max(ypart _pa_,ypart _sa_)) ; - % we need to compensate for topskip enlarged areas - _pa_ - if abs(ypart _pa_ - ypart _sa_) > par_line_height : - -- (xpart _pa_ + par_hang_indent,ypart _pa_) - -- (xpart _pa_ + par_hang_indent,ypart _sa_) - fi - else : - (xpart lrcorner multipar, ypart _sa_) - fi - enddef ; - - def test_multipar = - multipar := - llcorner multipar -- - urcorner multipar -- - lrcorner multipar -- - ulcorner multipar -- - cycle ; - enddef ; - - % first loop - - for i=1 upto NOfTextAreas : - - TopSkipCorrection := 0 ; - - multipar := set_multipar(i) ; - - % watch how we compensate for negative indentation - - if (nxy[fpos]=RealPageNumber) and (InsideTextArea(i,par_start_pos)) : - - % first one in chain - - ii := i ; - - if (nxy[tpos]=RealPageNumber) and (InsideTextArea(i,llxy[tpos])) : - - % in same area - - nn := i ; - - if compensate_multi_par_topskip and (round(LineHeight-ph-pd)=0) : - - TopSkipCorrection := TopSkip - StrutHeight ; - - if round(ypart ulxy[fpos] + TopSkipCorrection) = - round(ypart ulcorner TextAreas[i]) : - ulxy[fpos] := ulxy[fpos] shifted (0,TopSkipCorrection) ; - urxy[fpos] := urxy[fpos] shifted (0,TopSkipCorrection) ; - else : - TopSkipCorrection := 0 ; - fi ; - - fi ; - - if ypart llxy[fpos] = ypart llxy[tpos] : - - multipar := - llxy[fpos] -- - lrxy[tpos] -- - %urxy[tpos] -- - snapped_multi_pos(urxy[tpos]) -- - %ulxy[fpos] -- - snapped_multi_pos(ulxy[fpos]) -- - cycle ; - - save_multipar (i,1,multipar) ; - - elseif (ypart llxy[fpos] = ypart ulxy[tpos]) and - (xpart llxy[tpos] < xpart llxy[fpos]) : - - % two loners - - multipar := if obey_multi_par_hang : - - right_bottom_hang(true) -- - right_top_hang(true) -- - snapped_multi_pos(urxy[fpos]) -- - lrxy[fpos] -- - - else : - - llxy[fpos] -- - (xpart urcorner multipar, ypart llxy[fpos]) -- - (xpart urcorner multipar, ypart ulxy[fpos]) -- - snapped_multi_pos(ulxy[fpos]) -- - - fi cycle ; - - save_multipar (i,1,multipar) ; - - multipar := set_multipar(i) ; - - multipar := if obey_multi_par_hang : - - left_bottom_hang(true) -- - llxy[tpos] -- - snapped_multi_pos(ulxy[tpos]) -- - left_top_hang(true) -- - - else : - - (xpart llcorner multipar, ypart llxy[tpos]) -- - llxy[tpos] -- - snapped_multi_pos(ulxy[tpos]) -- - (xpart llcorner multipar, ypart ulxy[tpos]) -- - - fi cycle ; - - save_multipar (i,1,multipar) ; - - else : - - multipar := if obey_multi_par_hang : - - left_bottom_hang(true) -- - llxy[tpos] -- - %ulxy[tpos] -- - snapped_multi_pos(ulxy[tpos]) -- - right_bottom_hang(true) -- - right_top_hang(true) -- - %urxy[fpos] -- - snapped_multi_pos(urxy[fpos]) -- - lrxy[fpos] -- - left_top_hang(true) -- - - else : - - (xpart llcorner multipar, ypart llxy[tpos]) -- - llxy[tpos] -- - %ulxy[tpos] -- - snapped_multi_pos(ulxy[tpos]) -- - (xpart lrcorner multipar, ypart ulxy[tpos]) -- - (xpart urcorner multipar, ypart urxy[fpos]) -- - %urxy[fpos] -- - snapped_multi_pos(urxy[fpos]) -- - lrxy[fpos] -- - (xpart ulcorner multipar, ypart lrxy[fpos]) -- - - fi cycle ; - - save_multipar (i,1,multipar) ; - - fi ; - - elseif (nxy[tpos]=RealPageNumber) : - - % outside text area, fall back / test on: pascal werkboek - - multipar := - - llxy[fpos] -- - lrxy[tpos] -- - urxy[tpos] -- - ulxy[fpos] -- cycle ; - - save_multipar (i,1,multipar) ; - - else : - - multipar := if obey_multi_par_hang : - - left_bottom_hang(false) -- - right_bottom_hang(false) -- - right_top_hang(false) -- - %urxy[fpos] -- - snapped_multi_pos(urxy[fpos]) -- - lrxy[fpos] -- - left_top_hang(false) -- - - else : - - llcorner multipar -- - lrcorner multipar -- - (xpart urcorner multipar, ypart urxy[fpos]) -- - %urxy[fpos] -- - snapped_multi_pos(urxy[fpos]) -- - lrxy[fpos] -- - (xpart ulcorner multipar, ypart lrxy[fpos]) -- - - fi cycle ; - - save_multipar (i,1,multipar) ; - - fi ; - - elseif (nxy[tpos]=RealPageNumber) and (InsideTextArea(i,llxy[tpos])) : - - % last one in chain - - nn := i ; - - if obey_multi_par_hang and obey_multi_par_more : - - multipar := - x_left_top_hang(i,true) -- - x_right_top_hang(i,true) -- - x_right_bottom_hang(i,true) -- -% ulxy[tpos] -- -snapped_multi_pos(ulxy[tpos]) -- - llxy[tpos] -- - x_left_bottom_hang(i,true) -- - cycle ; - - else : - - multipar := - ulcorner multipar -- - urcorner multipar -- - (xpart lrcorner multipar, ypart urxy[tpos]) -- -% ulxy[tpos] -- -snapped_multi_pos(ulxy[tpos]) -- - llxy[tpos] -- - (xpart llcorner multipar, ypart llxy[tpos]) -- - cycle ; - - fi ; - - save_multipar (i,3,multipar) ; - - else : - - % handled later - - fi ; - - endfor ; - - % second loop - - for i=ii+1 upto nn-1 : - - % rest of chain / todo : hang - -%if (nxy[fpos]<=RealPageNumber) and (nxy[tpos]>=RealPageNumber) : - - multipar := set_multipar(i) ; - - if obey_multi_par_hang and obey_multi_par_more : - - multipar := - x_left_top_hang(i,false) -- - x_right_top_hang(i,false) -- - x_right_bottom_hang(i,false) -- - x_left_bottom_hang(i,false) -- - cycle ; - - fi ; - - save_multipar(i,2,multipar) ; - -%fi ; - - endfor ; - - if span_multi_column_pars : - endgroup ; - fi ; - -enddef ; - -color boxgridcolor ; boxgridcolor := .8red ; -color boxlinecolor ; boxlinecolor := .8blue ; -color boxfillcolor ; boxfillcolor := .8white ; -numeric boxgridtype ; boxgridtype := 0 ; -numeric boxlinetype ; boxlinetype := 1 ; -numeric boxfilltype ; boxfilltype := 1 ; -pair boxgriddirection ; boxgriddirection := up ; -numeric boxgridwidth ; boxgridwidth := 1pt ; -numeric boxlinewidth ; boxlinewidth := 1pt ; -numeric boxlineradius ; boxlineradius := 0pt ; -numeric boxfilloffset ; boxfilloffset := 0pt ; -numeric boxgriddistance ; boxgriddistance := .5cm ; - -def draw_box = - draw pxy withcolor boxlinecolor withpen pencircle scaled boxlinewidth ; - draw lxy -- rxy withcolor boxlinecolor withpen pencircle scaled boxgridwidth ; -enddef ; - -def draw_par = % 1 2 11 12 - do_draw_par(pxy) ; do_draw_par(txy) ; do_draw_par(bxy) ; - for i = pxy, txy, bxy : - if boxgridtype= 1 : - boxgriddirection := origin ; - draw baseline_grid (i,boxgriddirection,true ) withcolor boxgridcolor ; - elseif boxgridtype= 2 : - boxgriddirection := origin ; - draw baseline_grid (i,boxgriddirection,false) withcolor boxgridcolor ; - elseif boxgridtype=11 : - draw graphic_grid(i,boxgriddistance,boxgriddistance,boxgriddistance/2,boxgriddistance/2) ; - elseif boxgridtype=12 : - draw graphic_grid(i,boxgriddistance,boxgriddistance,0,0) ; - fi ; - endfor ; -enddef ; - -def do_show_par (expr p, r, c) = - if length(p) > 2 : for i=0 upto length(p) : - draw fullcircle scaled r shifted point i of p - withpen pencircle scaled .5pt withcolor c ; - endfor ; fi ; - draw p withpen pencircle scaled .5pt withcolor c ; -enddef ; - -def show_par = - if length(mxy) > 2 : - draw mxy dashed evenly - withpen pencircle scaled .5pt withcolor .5white ; - fi ; - do_show_par(txy, 4pt, .5green) ; - do_show_par(bxy, 6pt, .5blue ) ; - do_show_par(pxy, 8pt, .5red ) ; - draw pref withpen pencircle scaled 2pt ; -enddef ; - -def draw_multi_pars = - for i=1 upto nofmultipars : - do_draw_par(multipars[i]) ; - if boxgridtype= 1 : - draw baseline_grid (multipars[i],up,true ) withcolor boxgridcolor ; - elseif boxgridtype= 2 : - draw baseline_grid (multipars[i],up,false) withcolor boxgridcolor ; - elseif boxgridtype=11 : - draw graphic_grid(multipars[i],boxgriddistance,boxgriddistance,boxgriddistance/2,boxgriddistance/2) ; - elseif boxgridtype=12 : - draw graphic_grid(multipars[i],boxgriddistance,boxgriddistance,0,0) ; - fi ; - endfor ; -enddef ; - -def show_multi_pars = - for i=1 upto nofmultipars : - do_show_par(multipars[i], 6pt, .5blue) ; - endfor ; -enddef ; - -vardef do_draw_par (expr p) = - if (length p>2) and (bbwidth(p)>1) and (bbheight(p)>1) : - save pp ; path pp ; - if (boxlineradius>0) and (boxlinetype=2) : - pp := p cornered boxlineradius ; - else : - pp := p ; - fi ; - if boxfilltype>0 : -if boxfilloffset>0 : - % temporary hack - begingroup ; interim linejoin := mitered ; - filldraw pp withcolor boxfillcolor withpen pencircle scaled (2*boxfilloffset) ; - endgroup ; -else : - fill pp withcolor boxfillcolor ; -fi ; - fi ; - if boxlinetype>0 : - draw pp withcolor boxlinecolor withpen pencircle scaled boxlinewidth ; - fi ; - fi ; -enddef ; - -vardef baseline_grid (expr pxy, pdir, at_baseline) = - if (par_line_height>0) and (bbheight(pxy)>1) and (bbwidth(pxy)>1) and (boxgridwidth>0) : - save i, grid ; picture grid ; pair start ; - def _do_ (expr start) = - draw start -- start shifted (bbwidth(pxy),0) - withpen pencircle scaled boxgridwidth - withcolor boxgridcolor ; - enddef ; - grid := image - ( %fails with inlinespace - % - if pdir=up : - for i = if at_baseline : par_strut_depth else : 0 fi - step par_line_height - until max(bbheight(pxy),par_line_height) : - _do_ (llcorner pxy shifted (0,+i)) ; - endfor ; - else : - for i = if at_baseline : par_strut_height else : 0 fi - step par_line_height - until bbheight(pxy) : - _do_ (ulcorner pxy shifted (0,-i)) ; - endfor ; - fi ; - ) ; - clip grid to pxy ; - grid - else : - nullpicture - fi -enddef ; - -vardef graphic_grid (expr pxy, dx, dy, x, y) = - if (bbheight(pxy)>dy) and (bbwidth(pxy)>dx) and (boxgridwidth>0) : - save grid ; picture grid ; - grid := image - ( for i = xpart llcorner pxy step dx until xpart lrcorner pxy : - draw (i,ypart llcorner pxy) -- (i,ypart ulcorner pxy) - withpen pencircle scaled boxgridwidth ; - endfor ; - for i = ypart llcorner pxy step dy until ypart ulcorner pxy : - draw (xpart llcorner pxy,i) -- (xpart lrcorner pxy,i) - withpen pencircle scaled boxgridwidth ; - endfor ) shifted (x,y) ; - clip grid to pxy ; - grid - else : - nullpicture - fi -enddef ; - -def anchor_box (expr n,x,y,w,h,d) = - currentpicture := currentpicture shifted (-x,-y) ; -enddef ; - -let draw_area = draw_box ; -let anchor_area = anchor_box ; -let anchor_par = anchor_box ; - -endinput ; diff --git a/metapost/context/mp-form.mp b/metapost/context/mp-form.mp deleted file mode 100644 index b5c06b11a..000000000 --- a/metapost/context/mp-form.mp +++ /dev/null @@ -1,393 +0,0 @@ -% Hans Hagen / October 2000 -% -% This file is mostly a copy from the file format.mp, that -% comes with MetaPost and is written by John Hobby. This file -% is meant to be compatible, but has a few more features, -% controlled by the variables: -% -% fmt_initialize when false, initialization is skipped -% fmt_precision the default accuracy (default=3) -% fmt_separator the pattern separator (default=%) -% fmt_zerocheck activate extra sci notation zero check -% -% instead of a picture, one can format a number in a for TeX -% acceptable input string - -boolean mant_font ; mant_font := true ; % signals graph not to load form - -if known fmt_loaded : expandafter endinput fi ; - boolean fmt_loaded ; fmt_loaded := true ; - -if unknown fmt_precision : - numeric fmt_precision ; fmt_precision := 3 ; -fi ; - -if unknown fmt_initialize : - boolean fmt_initialize ; fmt_initialize := true ; -fi ; - -if unknown fmt_separator : - string fmt_separator ; fmt_separator := "%" ; -fi ; - -if unknown fmt_zerocheck : - boolean fmt_zerocheck ; fmt_zerocheck := false ; -fi ; - -boolean fmt_metapost ; fmt_metapost := true ; % == use old method - -% As said, all clever code is from John, the more stupid -% extensions are mine. The following string variables are -% responsible for the TeX formatting. - -% TeX specs when using TeX instead of pseudo TeX. - -string sFebraise_ ; sFebraise_ := "{" ; -string sFeeraise_ ; sFeeraise_ := "}" ; -string sFebmath_ ; sFebmath_ := "$" ; -string sFeemath_ ; sFeemath_ := "$" ; - -string sFmneg_ ; sFmneg_ := "-" ; -string sFemarker_ ; sFemarker_ := "{\times}10^" ; -string sFeneg_ ; sFeneg_ := "-" ; -string sFe_plus ; sFe_plus := "" ; % "+" - -def sFe_base = Fline_up_("1", sFemarker_) enddef ; - -% Macros for generating typeset pictures of computed numbers -% -% format(f,x) typeset generalized number x using format string f -% Mformat(f,x) like format, but x is in Mlog form (see marith.mp) -% init_numbers(s,m,x,sn,e) choose typeset style given sample sign, mantissa,... -% roundd(x,d) round numeric x to d places right of decimal point -% Fe_base what precedes the exponent for typeset powers of 10 -% Fe_plus plus sign if any for typesetting positive exponents -% Ten_to[] powers of ten for indices 0,1,2,3,4 -% -% New are: -% -% formatstr(f,x) TeX string representing x using format f -% Mformatstr(f,x) like Mformatstr, but x is in Mlog form - -% Other than the above-documented user interface, all -% externally visible names start with F and end with _. - -% Allow big numbers in token lists - -begingroup interim warningcheck := 0 ; - -%%% Load auxiliary macros. - -input string -input marith - -%%% Choosing the Layout %%% - -picture Fmneg_, Femarker_, Feneg_, Fe_base, Fe_plus ; -string Fmfont_, Fefont_ ; -numeric Fmscale_, Fescale_, Feraise_ ; - -% Argument -% -% s is a leading minus sign -% m is a 1-digit mantissa -% x is whatever follows the mantissa -% sn is a leading minus for the exponent, and -% e is a 1-digit exponent. -% -% Numbers in scientific notation are constructed by placing -% these pieces side-by-side; decimal numbers use only m -% and/or s. To get exponents with leading plus signs, assign -% to Fe_plus after calling init_numbers. To do something -% special with a unit mantissa followed by x, assign to -% Fe_base after calling init_numbers. - -vardef init_numbers(expr s, m, x, sn, e) = - Fmneg_ := s ; - for p within m : - Fmfont_ := fontpart p ; - Fmscale_ := xxpart p ; - exitif true ; - endfor - Femarker_ := x ; - Feneg_ := sn ; - for p within e : - Fefont_ := fontpart p ; - Fescale_ := xxpart p ; - Feraise_ := ypart llcorner p ; - exitif true ; - endfor - if fmt_metapost : - Fe_base := Fline_up_("1" infont Fmfont_ scaled Fmscale_, Femarker_) ; - % else : - % sFe_base := Fline_up_("1", sFemarker_) ; - fi ; - Fe_plus := nullpicture ; -enddef ; - -%%% Low-Level Typesetting %%% - -vardef Fmant_(expr x) = %%% adapted by HH %%% - if fmt_metapost : - (decimal abs x infont Fmfont_ scaled Fmscale_) - else : - (decimal abs x) - fi -enddef ; - -vardef Fexp_(expr x) = %%% adapted by HH %%% - if fmt_metapost : - (decimal x infont Fefont_ scaled Fescale_ shifted (0,Feraise_)) - else : - (decimal x) - fi -enddef ; - -vardef Fline_up_(text t_) = %%% adapted by HH %%% - if fmt_metapost : - save p_, c_ ; - picture p_ ; p_ = nullpicture ; - pair c_ ; c_ = (0,0) ; - for q_ = t_ : - addto p_ also q_ if string q_ : infont defaultfont scaled defaultscale fi - shifted c_ ; - c_ := (xpart lrcorner p_, 0) ; - endfor - p_ - else : - "" for q_ = t_ : & q_ endfor - fi -enddef ; - -vardef Fdec_o_(expr x) = %%% adapted by HH %%% - if x<0 : - Fline_up_(if fmt_metapost : Fmneg_ else : sFmneg_ fi, Fmant_(x)) - else : - Fmant_(x) - fi -enddef ; - -vardef Fsci_o_(expr x, e) = %%% adapted by HH %%% - if fmt_metapost : - Fline_up_ - (if x < 0 : Fmneg_,fi - if abs x = 1 : Fe_base else : Fmant_(x), Femarker_ fi, - if e < 0 : Feneg_ else : Fe_plus fi, - Fexp_(abs e)) - else : - Fline_up_ - (if x < 0 : sFmneg_, fi - if abs x = 1 : sFe_base else : Fmant_(x), sFemarker_ fi, - sFebraise_, - if e < 0 : sFeneg_ else : sFe_plus fi, - Fexp_(abs e), - sFeeraise_) - fi -enddef ; - -% Assume prologues=1 implies troff mode. TeX users who want -% prologues on should use some other positive value. The mpx -% file mechanism requires separate input files here. - -if fmt_initialize : %%% adapted by HH - if prologues = 1 : input troffnum else : input texnum fi -fi ; - -%%% Scaling and Rounding %%% - -% Find a pair p where x = xpart p*10**ypart p and either p = -% (0,0) or xpart p is between 1000 and 9999.99999. This is -% the `exponent form' of x. - -vardef Feform_(expr x) = - interim warningcheck := 0 ; - if string x : - Meform(Mlog_str x) - else : - save b, e ; - b = x ; e = 0 ; - if abs b >= 10000 : - (b/10, 1) - elseif b = 0 : - origin - else : - forever : - exitif abs b >= 1000 ; - b := b*10 ; e := e-1 ; - endfor - (b, e) - fi - fi -enddef ; - -% The marith.mp macros include a similar macro Meform that -% converts from `Mlog form' to exponent form. In case -% rounding has made the xpart of an exponent form number too -% large, fix it. - -vardef Feadj_(expr x, y) = - if abs x >= 10000 : (x/10, y+1) else : (x,y) fi -enddef ; - -% Round x to d places right of the decimal point. When d<0, -% round to the nearest multiple of 10 to the -d. - -vardef roundd(expr x, d) = - if abs d > 4 : - if d > 0 : x else : 0 fi - elseif d > 0 : - save i ; i = floor x ; - i + round(Ten_to[d]*(x-i))/Ten_to[d] - else : - round(x/Ten_to[-d])*Ten_to[-d] - fi -enddef ; - -Ten_to0 = 1 ; -Ten_to1 = 10 ; -Ten_to2 = 100 ; -Ten_to3 = 1000 ; -Ten_to4 = 10000 ; - -% Round an exponent form number p to k significant figures. - -primarydef p Fprec_ k = - Feadj_(roundd(xpart p,k-4), ypart p) -enddef ; - -% Round an exponent form number p to k digits right of the -% decimal point. - -primarydef p Fdigs_ k = - Feadj_(roundd(xpart p,k+ypart p), ypart p) -enddef ; - -%%% High-Level Routines %%% - -% The following operators convert z from exponent form and -% produce typeset output: Formsci_ generates scientific -% notation; Formdec_ generates decimal notation; and -% Formgen_ generates whatever is likely to be most compact. - -vardef Formsci_(expr z) = %%% adapted by HH %%% - if fmt_zerocheck and (z = origin) : - Fsci_o_(0,0) - else : - Fsci_o_(xpart z/1000, ypart z + 3) - fi -enddef ; - -vardef Formdec_(expr z) = - if ypart z > 0 : - Formsci_(z) - else : - Fdec_o_ - (xpart z if ypart z >= -4 : - /Ten_to[-ypart z] - else : - for i = ypart z upto -5 : /(10) endfor /10000 - fi) - fi -enddef ; - -vardef Formgen_(expr q) = - clearxy ; (x,y) = q ; - if x = 0 : Formdec_ - elseif y >= -6 : Formdec_ - else : Formsci_ - fi (q) -enddef ; - -def Fset_item_(expr s) = %%% adapted by HH %%% - if s <> "" : - if fmt_metapost : - s infont defaultfont scaled defaultscale, - else : - s, - fi - fi -enddef ; - -% For each format letter, the table below tells how to -% round and typeset a quantity z in exponent form. -% -% e scientific, p significant figures -% p decimal, p digits right of the point -% g decimal or scientific, p sig. figs. -% G decimal or scientific, p digits - -string fmt_[] ; - -fmt_[ASCII "e"] = "Formsci_(z Fprec_ p)" ; -fmt_[ASCII "f"] = "Formdec_(z Fdigs_ p)" ; -fmt_[ASCII "g"] = "Formgen_(z Fprec_ p)" ; -fmt_[ASCII "G"] = "Formgen_(z Fdigs_ p)" ; - -% The format and Mformat macros take a format string f and -% generate typeset output for a numeric quantity x. String f -% should contain a `%' followed by an optional number and one -% of the format letters defined above. The number should be -% an integer giving the precision (default 3). - -vardef isfmtseparator primary c = %%% added by HH %%% - ((c <> fmt_separator) and (c <> "%")) -enddef ; - -vardef dofmt_@#(expr f, x) = %%% adapted by HH %%% - initialize_numbers ; - if f = "" : - if fmt_metapost : nullpicture else : "" fi - else : - interim warningcheck := 0 ; - save k, l, s, p, z ; - pair z ; z = @#(x) ; - % the next adaption is okay - % k = 1 + cspan(f, fmt_separator <> ) ; - % but best is to support both % and fmt_separator - k = 1 + cspan(f, isfmtseparator) ; - % - l-k = cspan(substring(k,infinity) of f, isdigit) ; - p = if l > k : - scantokens substring(k,l) of f - else : - fmt_precision - fi ; - string s ; s = fmt_[ASCII substring (l,l+1) of f] ; - if unknown s : - if k <= length f : - errmessage("No valid format letter found in "&f) ; - fi - s = if fmt_metapost : "nullpicture" else : "" fi ; - fi - Fline_up_ - (Fset_item_(substring (0,k-1) of f) - if not fmt_metapost : sFebmath_, fi - scantokens s, - if not fmt_metapost : sFeemath_, fi - Fset_item_(substring (l+1,infinity) of f) - if fmt_metapost : nullpicture else : "" fi) - fi - hide (fmt_metapost := true) -enddef ; - -%%% so far %%% - -vardef format (expr f, x) = - fmt_metapost := true ; dofmt_.Feform_(f,x) -enddef ; - -vardef Mformat(expr f, x) = - fmt_metapost := true ; dofmt_.Meform (f,x) -enddef ; - -vardef formatstr (expr f, x) = - fmt_metapost := false ; dofmt_.Feform_(f,x) -enddef ; - -vardef Mformatstr(expr f, x) = - fmt_metapost := false ; dofmt_.Meform (f,x) -enddef ; - -% Restore warningcheck to previous value. - -endgroup ; diff --git a/metapost/context/mp-func.mp b/metapost/context/mp-func.mp deleted file mode 100644 index d8646ef3b..000000000 --- a/metapost/context/mp-func.mp +++ /dev/null @@ -1,59 +0,0 @@ -%D \module -%D [ file=mp-func.mp, -%D version=2001.12.29, -%D title=\CONTEXT\ \METAPOST\ graphics, -%D subtitle=function hacks, -%D author=Hans Hagen, -%D date=\currentdate, -%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] -%C -%C This module is part of the \CONTEXT\ macro||package and is -%C therefore copyrighted by \PRAGMA. See licen-en.pdf for -%C details. - -%D Under construction. - -if unknown context_tool : input mp-tool ; fi ; -if known context_func : endinput ; fi ; - -boolean context_func ; context_func := true ; - -string pathconnectors[] ; - -pathconnectors[0] := "," ; -pathconnectors[1] := "--" ; -pathconnectors[2] := ".." ; -pathconnectors[3] := "..." ; - -vardef function (expr f) (expr u, t, b, e, s) = save x ; numeric x ; - for xx := b step s until e : - hide (x := xx ;) if xx>b : scantokens(pathconnectors[f]) fi - (scantokens(u),scantokens(t)) - endfor -enddef ; - -def punkedfunction = function (1) enddef ; -def curvedfunction = function (2) enddef ; -def tightfunction = function (3) enddef ; - -vardef constructedpath (expr f) (text t) = - save ok ; boolean ok ; ok := false ; - for i=t : - if ok : scantokens(pathconnectors[f]) else : ok := true ; fi i - endfor -enddef ; - -def punkedpath = constructedpath (1) enddef ; -def curvedpath = constructedpath (2) enddef ; -def tightpath = constructedpath (3) enddef ; - -vardef constructedpairs (expr f) (text p) = - save i ; i := -1 ; - forever : exitif unknown p[incr(i)] ; - if i>0 : scantokens(pathconnectors[f]) fi p[i] - endfor -enddef ; - -def punkedpairs = constructedpairs (1) enddef ; -def curvedpairs = constructedpairs (2) enddef ; -def tightpairs = constructedpairs (3) enddef ; diff --git a/metapost/context/mp-grid.mp b/metapost/context/mp-grid.mp deleted file mode 100644 index cfcc6bc15..000000000 --- a/metapost/context/mp-grid.mp +++ /dev/null @@ -1,143 +0,0 @@ -%D \module -%D [ file=mp-grid.mp, -%D version=2000.07.10, -%D title=\CONTEXT\ \METAPOST\ graphics, -%D subtitle=grid support, -%D author=Hans Hagen, -%D date=\currentdate, -%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] -%C -%C This module is part of the \CONTEXT\ macro||package and is -%C therefore copyrighted by \PRAGMA. See licen-en.pdf for -%C details. - -%D Under construction. - -if unknown context_tool : input mp-tool ; fi ; -if known context_grid : endinput ; fi ; - -boolean context_grid ; context_grid := true ; - -string fmt_separator ; fmt_separator := "@" ; -numeric fmt_precision ; fmt_precision := 3 ; -boolean fmt_initialize ; fmt_initialize := false ; -boolean fmt_zerocheck ; fmt_zerocheck := true ; - -if unknown fmt_loaded : input mp-form ; fi ; - -boolean fmt_pictures ; fmt_pictures := true ; - -def do_format = if fmt_pictures : format else : formatstr fi enddef ; -def do_mformat = if fmt_pictures : Mformat else : Mformatstr fi enddef ; - -def hlingrid (expr Min, Max, Step, Length, Width) text t = - image ( for i=Min step Step until Max : - draw (origin--(Width,0)) shifted (0,i*(Length/Max)) t ; - endfor ; ) ; -enddef ; - -def vlingrid (expr Min, Max, Step, Length, Height) text t = - image ( for i=Min step Step until Max : - draw (origin--(0,Height)) shifted (i*(Length/Max),0) t ; - endfor ; ) ; -enddef ; - -def hloggrid (expr Min, Max, Step, Length, Width) text t = - image ( for i=max(Min,1) step Step until min(Max,10) : - draw (origin--(Width,0)) shifted (0,Length*log(i)) t ; - endfor ; ) ; -enddef ; - -def vloggrid (expr Min, Max, Step, Length, Height) text t = - image ( for i=max(Min,1) step Step until min(Max,10) : - draw (origin--(0,Height)) shifted (Length*log(i),0) t ; - endfor ; ) ; -enddef ; - -vardef hlintext@#(expr Min, Max, Step, Length, Format) text t = - image ( do_initialize_numbers ; - for i=Min step Step until Max : - draw textext@#(do_format(Format,i)) shifted (0,i*(Length/Max)) t ; - endfor ; ) -enddef ; - -vardef vlintext@#(expr Min, Max, Step, Length, Format) text t = - image ( do_initialize_numbers ; - for i=Min step Step until Max : - draw textext@#(do_format(Format,i)) shifted (i*(Length/Max),0) t ; - endfor ; ) -enddef ; - -vardef hlogtext@#(expr Min, Max, Step, Length, Format) text t = - image ( do_initialize_numbers ; - for i=max(Min,1) step Step until min(Max,10) : - draw textext@#(do_format(Format,i)) shifted (0,Length*log(i)) t ; - endfor ; ) -enddef ; - -vardef vlogtext@#(expr Min, Max, Step, Length, Format) text t = - image ( do_initialize_numbers ; - for i=max(Min,1) step Step until min(Max,10) : - draw textext@#(do_format(Format,i)) shifted (Length*log(i),0) t ; - endfor ; ) -enddef ; - -vardef hlinlabel@#(expr Min, Max, Step, Length) text t = - image ( - for i=Min step Step until Max : - draw thelabel@#(decimal i,(0,i*(Length/Max))) t ; - endfor ; ) -enddef ; - -vardef vlinlabel@#(expr Min, Max, Step, Length) text t = - image ( - for i=Min step Step until Max : - draw thelabel@#(decimal i,(i*(Length/Max),0)) t ; - endfor ; ) -enddef ; - -boolean numbers_initialized ; numbers_initialized := false ; - -def do_initialize_numbers = - if not numbers_initialized : - init_numbers ( textext.raw("$-$") , - textext.raw("$1$") , - textext.raw("${\times}10$") , - textext.raw("${}^-$") , - textext.raw("${}^2$") ) ; - numbers_initialized := true ; - fi ; -enddef ; - -def initialize_numbers = - numbers_initialized := false ; do_initialize_numbers ; -enddef ; - -vardef linlog(expr xy) = ( xpart xy, log(ypart xy)) enddef ; -vardef loglin(expr xy) = (log(xpart xy), ypart xy) enddef ; -vardef loglog(expr xy) = (log(xpart xy), log(ypart xy)) enddef ; -vardef linlin(expr xy) = ( (xpart xy), (ypart xy)) enddef ; - -vardef loglinpath primary p = processpath (p) (loglin) enddef ; -vardef linlogpath primary p = processpath (p) (linlog) enddef ; -vardef loglogpath primary p = processpath (p) (loglog) enddef ; -vardef linlinpath primary p = processpath (p) (linlin) enddef ; - -def processpath (expr p) (text pp) = - if path p : - for i=0 upto length(p)-1 : - (pp(point i of p)) .. controls - (pp(postcontrol i of p)) and - (pp(precontrol (i+1) of p)) .. - endfor - if cycle p : - cycle - else : - (pp(point length(p) of p)) - fi - elseif pair p : - (pp(p)) - else : - p - fi -enddef ; diff --git a/metapost/context/mp-grph.mp b/metapost/context/mp-grph.mp deleted file mode 100644 index 957a60ec8..000000000 --- a/metapost/context/mp-grph.mp +++ /dev/null @@ -1,290 +0,0 @@ -%D \module -%D [ file=mp-grph.mp, -%D version=2000.12.14, -%D title=\CONTEXT\ \METAPOST\ graphics, -%D subtitle=graphic text support, -%D author=Hans Hagen, -%D date=\currentdate, -%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] -%C -%C This module is part of the \CONTEXT\ macro||package and is -%C therefore copyrighted by \PRAGMA. See licen-en.pdf for -%C details. - -%D Under construction. - -if unknown context_tool : input mp-tool ; fi ; -if known context_grph : endinput ; fi ; - -boolean context_grph ; context_grph := true ; - -string CRLF ; CRLF := char 10 & char 13 ; - -picture _currentpicture_ ; - -def beginfig (expr c) = - begingroup - charcode := c ; - resetfig ; - scantokens extra_beginfig ; -enddef ; - -def resetfig = - clearxy ; - clearit ; - clearpen ; - pickup defaultpen ; - interim linecap := linecap ; - interim linejoin := linejoin ; - interim miterlimit := miterlimit ; - save _background_ ; color _background_ ; _background_ := background ; - save background ; color background ; background := _background_ ; - drawoptions () ; -enddef ; - -def protectgraphicmacros = - save showtext ; - save beginfig ; let beginfig = begingraphictextfig ; - save endfig ; let endfig = endgraphictextfig ; - save end ; let end = relax ; - interim prologues := prologues ; - resetfig ; -enddef ; - -numeric currentgraphictext ; currentgraphictext := 0 ; -string graphictextformat ; graphictextformat := "plain" ; -string graphictextstring ; graphictextstring := "" ; -string graphictextfile ; graphictextfile := "dummy.mpo" ; - -def savegraphictext (expr str) = - graphictextfile := jobname & ".mpo" ; - if (graphictextstring<>"") : - write graphictextstring to graphictextfile ; - graphictextstring := "" ; - fi ; - write str to graphictextfile ; - let erasegraphictextfile = relax ; -enddef ; - -def erasegraphictextfile = - graphictextfile := jobname & ".mpo" ; - write EOF to graphictextfile ; - let erasegraphictextfile = relax ; -enddef ; - -extra_beginfig := extra_beginfig & " erasegraphictextfile ;" ; - -def begingraphictextfig (expr n) = - foundpicture := n ; scratchpicture := nullpicture ; -enddef ; - -def endgraphictextfig = - if foundpicture = currentgraphictext : - expandafter endinput - else : - scratchpicture := nullpicture ; - fi ; -enddef ; - -def loadfigure primary filename = - doloadfigure (filename) -enddef ; - -def doloadfigure (expr filename) text figureattributes = - begingroup ; - save figurenumber, figurepicture, number, fixedplace ; - numeric figurenumber ; figurenumber := 0 ; - boolean figureshift ; figureshift := true ; - picture figurepicture ; figurepicture := currentpicture ; - def number primary n = hide(figurenumber := n) enddef ; - def fixedplace = hide(figureshift := false) enddef ; - protectgraphicmacros ; - % defaults - interim linecap := rounded ; - interim linejoin := rounded ; - interim miterlimit := 10 ; - % - currentpicture := nullpicture ; - draw fullcircle figureattributes ; % expand number - currentpicture := nullpicture ; - def beginfig (expr n) = - currentpicture := nullpicture ; - if (figurenumber=n) or (figurenumber=0) : - let endfig = endinput ; - fi ; - enddef ; - let endfig = relax ; - readfile(filename) ; - if figureshift : - currentpicture := currentpicture shifted -llcorner currentpicture ; - fi ; - addto figurepicture also currentpicture figureattributes ; - currentpicture := figurepicture ; - endgroup ; -enddef ; - -def graphictext primary t = - dographictext(t) -enddef ; - -def dographictext (expr t) = - begingroup ; - if graphictextformat<>"" : - graphictextstring := - "% format=" & graphictextformat & CRLF & graphictextstring ; - graphictextformat := "" ; - fi ; - currentgraphictext := currentgraphictext + 1 ; - savegraphictext ("\startTEXpage[scale=10000]" & t & "\stopTEXpage") ; - dofinishgraphictext -enddef ; - -def redographictext primary t = - regraphictext(t) -enddef ; - -def regraphictext (expr t) = - begingroup ; - save currentgraphictext ; numeric currentgraphictext ; - currentgraphictext := t ; - dofinishgraphictext -enddef ; - -%D Believe it or not, but it took me half a day to uncover -%D the following neccessity: -%D -%D \starttypen -%D save withfillcolor, withdrawcolor ; -%D \stoptypen -%D -%D When we have more than one graphictext, these will be -%D defined after the first graphic. For some obscure reason, -%D this means that in the next graphic they will be called, but -%D afterwards the data and boolean are not set. Don't ask me -%D why. - -def dofinishgraphictext text x_op_x = - protectgraphicmacros ; - interim linecap := butt ; % normally rounded - interim linejoin := mitered ; % normally rounded - interim miterlimit := 10 ; % todo - let normalwithshade = withshade ; - save foundpicture, scratchpicture, str ; - save fill, draw, withshade, reversefill, outlinefill ; - save withfillcolor, withdrawcolor ; % quite important - numeric foundpicture ; picture scratchpicture ; string str ; - def draw expr p = - % the first, naive implementation was: - % addto scratchpicture doublepath p withpen currentpen ; - % but it is better to turn lines into fills - addto scratchpicture contour boundingbox - image (addto currentpicture doublepath p withpen currentpen) ; - enddef ; - def fill expr p = - addto scratchpicture contour p withpen currentpen ; - enddef ; - def f_op_f = enddef ; boolean f_color ; f_color := false ; - def d_op_d = enddef ; boolean d_color ; d_color := false ; - def s_op_s = enddef ; boolean s_color ; s_color := false ; - boolean reverse_fill ; reverse_fill := false ; - boolean outline_fill ; outline_fill := false ; - def reversefill = - hide(reverse_fill := true ) - enddef ; - def outlinefill = - hide(outline_fill := true ) - enddef ; - def withshade primary c = - hide(def s_op_s = normalwithshade c enddef ; s_color := true ) - enddef ; - def withfillcolor primary c = - hide(def f_op_f = withcolor c enddef ; f_color := true ) - enddef ; - def withdrawcolor primary c = - hide(def d_op_d = withcolor c enddef ; d_color := true ) - enddef ; - scratchpicture := nullpicture ; - addto scratchpicture doublepath origin x_op_x ; % pre-roll - for i within scratchpicture : % Below here is a dirty tricky test! - if (urcorner dashpart i) = origin : outline_fill := false ; fi ; - endfor ; - scratchpicture := nullpicture ; - readfile(jobname & ".mpy") ; - scratchpicture := (scratchpicture shifted -llcorner scratchpicture) scaled (1/10) ; - if not d_color and not f_color : d_color := true ; fi - if s_color : d_color := false ; f_color := false ; fi ; - if d_color and not reverse_fill : - for i within scratchpicture : - if f_color and outline_fill : - addto currentpicture doublepath pathpart i _op_ x_op_x f_op_f - dashed nullpicture ; - fi ; - if filled i : - addto currentpicture doublepath pathpart i _op_ x_op_x d_op_d ; - fi ; - endfor ; - fi ; - if f_color : - for i within scratchpicture : - if filled i : - addto currentpicture contour pathpart i _op_ x_op_x f_op_f - withpen pencircle scaled 0 ; - fi ; - endfor ; - fi ; - if d_color and reverse_fill : - for i within scratchpicture : - if filled i : - addto currentpicture doublepath pathpart i _op_ x_op_x d_op_d ; - fi ; - endfor ; - fi ; - if s_color : - for i within scratchpicture : - if filled i : - addto currentpicture contour pathpart i _op_ x_op_x s_op_s ; - fi ; - endfor ; - else : - for i within scratchpicture : - if stroked i : - addto currentpicture doublepath pathpart i _op_ x_op_x d_op_d ; - fi ; - endfor ; - fi ; - endgroup ; -enddef ; - -def resetgraphictextdirective = - graphictextstring := "" ; -enddef ; - -def graphictextdirective text t = - graphictextstring := graphictextstring & t & CRLF ; -enddef ; - -endinput - -% example - -input mp-grph ; - - graphictextformat := "context" ; -% graphictextformat := "plain" ; -% graphictextformat := "latex" ; graphictextdirective "\documentclass[]{article}" ; - -beginfig (1) ; - graphictext - "\vbox{\hsize10cm \input tufte }" - scaled 8 - withdrawcolor blue - withfillcolor red - withpen pencircle scaled 2pt ; -endfig ; - -beginfig(1) ; - loadfigure "gracht.mp" rotated 20 ; - loadfigure "koe.mp" number 1 scaled 2 ; -endfig ; - -end diff --git a/metapost/context/mp-page.mp b/metapost/context/mp-page.mp deleted file mode 100644 index 032844ce3..000000000 --- a/metapost/context/mp-page.mp +++ /dev/null @@ -1,421 +0,0 @@ -%D \module -%D [ file=mp-page.mp, -%D version=1999.03.10, -%D title=\CONTEXT\ \METAPOST\ graphics, -%D subtitle=page enhancements, -%D author=Hans Hagen, -%D date=\currentdate, -%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] -%C -%C This module is part of the \CONTEXT\ macro||package and is -%C therefore copyrighted by \PRAGMA. See mreadme.pdf for -%C details. - -%D This module is rather preliminary and subjected to -%D changes. - -if unknown context_tool : input mp-tool ; fi ; -if known context_page : endinput ; fi ; - -boolean context_page ; context_page := true ; - -if unknown PageStateAvailable : - boolean PageStateAvailable ; PageStateAvailable := false ; -fi ; - -if unknown OnRightPage : - boolean OnRightPage ; OnRightPage := true ; -fi ; - -if unknown InPageBody : - boolean InPageBody ; InPageBody := false ; -fi ; - -def SaveTextAreas = - path SavedTextAreas [] ; - path SavedTextColumns[] ; - numeric NOfSavedTextAreas ; - numeric NOfSavedTextColumns ; - for i=1 upto NOfTextAreas : - SavedTextAreas[i] := TextAreas[i] ; - endfor ; - for i=1 upto NOfTextColumns : - SavedTextColumns[i] := TextColumns[i] ; - endfor ; - NOfSavedTextAreas := NOfTextAreas ; - NOfSavedTextColumns := NOfTextColumns ; -enddef ; - -def ResetTextAreas = - path TextAreas[], TextColumns[] ; - numeric NOfTextAreas ; NOfTextAreas := 0 ; - numeric NOfTextColumns ; NOfTextColumns := 0 ; - numeric nofmultipars ; nofmultipars := 0 ; - TextAreas[0] := TextColumns[0] := origin -- cycle ; -enddef ; - -ResetTextAreas ; SaveTextAreas ; ; - -def RegisterTextArea (expr x, y, w, h, d) = - begingroup ; save p ; path p ; - p := unitsquare xyscaled(w,h+d) shifted (x,y-d) ; - if NOfTextAreas>0 : - % if needed, concatenate areas - if (round(llcorner TextAreas[NOfTextAreas]) = round(ulcorner p)) and - (round(lrcorner TextAreas[NOfTextAreas]) = round(urcorner p)) : - p := ulcorner TextAreas[NOfTextAreas] -- - urcorner TextAreas[NOfTextAreas] -- - lrcorner p -- - llcorner p -- - cycle ; - else : - NOfTextAreas := NOfTextAreas + 1 ; - fi ; - else : - NOfTextAreas := NOfTextAreas + 1 ; - fi ; - TextAreas[NOfTextAreas] := p ; - if NOfTextColumns>0 : - if (round(xpart llcorner TextColumns[NOfTextColumns]) = round(xpart ulcorner p)) and - (round(xpart lrcorner TextColumns[NOfTextColumns]) = round(xpart urcorner p)) : - p := ulcorner TextColumns[NOfTextColumns] -- - urcorner TextColumns[NOfTextColumns] -- - lrcorner p -- - llcorner p -- - cycle ; - else : - NOfTextColumns := NOfTextColumns + 1 ; - fi ; - else : - NOfTextColumns := NOfTextColumns + 1 ; - fi ; - TextColumns[NOfTextColumns] := p ; - endgroup ; -enddef ; - -%D We store a local area in slot zero. - -def RegisterLocalTextArea (expr x, y, w, h, d) = - TextAreas[0] := TextColumns[0] := unitsquare xyscaled(w,h+d) shifted (x,y-d) ; -enddef ; - -def ResetLocalTextArea = - TextAreas[0] := TextColumns[0] := origin -- cycle ; -enddef ; - -ResetLocalTextArea ; - -vardef InsideTextArea (expr _i_, _xy_) = - ( (round(xpart _xy_) >= round(xpart llcorner TextAreas[_i_])) and - (round(xpart _xy_) <= round(xpart lrcorner TextAreas[_i_])) and - (round(ypart _xy_) >= round(ypart llcorner TextAreas[_i_])) and - (round(ypart _xy_) <= round(ypart urcorner TextAreas[_i_])) ) -enddef ; - -vardef InsideSavedTextArea (expr _i_, _xy_) = - ( (round(xpart _xy_) >= round(xpart llcorner SavedTextAreas[_i_])) and - (round(xpart _xy_) <= round(xpart lrcorner SavedTextAreas[_i_])) and - (round(ypart _xy_) >= round(ypart llcorner SavedTextAreas[_i_])) and - (round(ypart _xy_) <= round(ypart urcorner SavedTextAreas[_i_])) ) -enddef ; - -vardef TextAreaX (expr x) = - numeric _TextAreaX_ ; _TextAreaX_ := 0 ; - for i := 1 upto NOfTextAreas : - if (round(x) >= round(xpart llcorner TextAreas[i])) and - (round(x) <= round(xpart lrcorner TextAreas[i])) : - _TextAreaX_ := xpart llcorner TextAreas[i] ; - fi ; - endfor ; - _TextAreaX_ -enddef ; - -vardef TextAreaY (expr y) = - numeric _TextAreaY_ ; _TextAreaY_ := 0 ; - for i := 1 upto NOfTextAreas : - if (round(y) >= round(ypart llcorner TextAreas[NOfTextAreas])) and - (round(y) <= round(ypart ulcorner TextAreas[NOfTextAreas])) : - _TextAreaY_ := ypart llcorner TextAreas[NOfTextAreas] ; - fi ; - endfor ; - _TextAreaY_ -enddef ; - -vardef TextAreaXY (expr x, y) = - pair _TextAreaXY_ ; _TextAreaXY_ := origin ; - for i := 1 upto NOfTextAreas : - if (round(x) >= round(xpart llcorner TextAreas[i])) and - (round(x) <= round(xpart lrcorner TextAreas[i])) and - (round(y) >= round(ypart llcorner TextAreas[i])) and - (round(y) <= round(ypart ulcorner TextAreas[i])) : - _TextAreaXY_ := llconer TextAreas[i] ; - fi ; - endfor ; - _TextAreaXY_ -enddef ; - -vardef TextAreaW (expr x) = - numeric _TextAreaW_ ; _TextAreaW_ := 0 ; - for i := 1 upto NOfTextAreas : - if (round(x) >= round(xpart llcorner TextAreas[i])) and - (round(x) <= round(xpart lrcorner TextAreas[i])) : - _TextAreaW_ := bbwidth(TextAreas[i]) ; - fi ; - endfor ; - _TextAreaW_ -enddef ; - -vardef TextAreaH (expr y) = - numeric _TextAreaH_ ; _TextAreaH_ := 0 ; - for i := 1 upto NOfTextAreas : - if (round(y) >= round(ypart llcorner TextAreas[i])) and - (round(y) <= round(ypart ulcorner TextAreas[i])) : - _TextAreaH_ := bbheight(TextAreas[i]) ; - fi ; - endfor ; - _TextAreaH_ -enddef ; - -vardef TextAreaWH (expr x, y) = - pair _TextAreaWH_ ; _TextAreaWH_ := origin ; - for i := 1 upto NOfTextAreas : - if (round(x) >= round(xpart llcorner TextAreas[i])) and - (round(x) <= round(xpart lrcorner TextAreas[i])) and - (round(y) >= round(ypart llcorner TextAreas[i])) and - (round(y) <= round(ypart ulcorner TextAreas[i])) : - _TextAreaWH_ := (bbwidth(TextAreas[i]),bbheight(TextAreas[i])) ; - fi ; - endfor ; - _TextAreaWH_ -enddef ; - -PageNumber := 0 ; -PaperHeight := 845.04684pt ; -PaperWidth := 597.50787pt ; -PrintPaperHeight := 845.04684pt ; -PrintPaperWidth := 597.50787pt ; -TopSpace := 71.12546pt ; -BottomSpace := 0.0pt ; -BackSpace := 71.13275pt ; -CutSpace := 0.0pt ; -MakeupHeight := 711.3191pt ; -MakeupWidth := 426.78743pt ; -TopHeight := 0.0pt ; -TopDistance := 0.0pt ; -HeaderHeight := 56.90294pt ; -HeaderDistance := 0.0pt ; -TextHeight := 597.51323pt ; -FooterDistance := 0.0pt ; -FooterHeight := 56.90294pt ; -BottomDistance := 0.0pt ; -BottomHeight := 0.0pt ; -LeftEdgeWidth := 0.0pt ; -LeftEdgeDistance := 0.0pt ; -LeftMarginWidth := 75.58197pt ; -LeftMarginDistance := 11.99829pt ; -TextWidth := 426.78743pt ; -RightMarginDistance := 11.99829pt ; -RightMarginWidth := 75.58197pt ; -RightEdgeDistance := 0.0pt ; -RightEdgeWidth := 0.0pt ; - -PageOffset := 0.0pt ; -PageDepth := 0.0pt ; - -LeftEdge := -4 ; Top := -40 ; -LeftEdgeSeparator := -3 ; TopSeparator := -30 ; -LeftMargin := -2 ; Header := -20 ; -LeftMarginSeparator := -1 ; HeaderSeparator := -10 ; -Text := 0 ; Text := 0 ; -RightMarginSeparator := +1 ; FooterSeparator := +10 ; -RightMargin := +2 ; Footer := +20 ; -RightEdgeSeparator := +3 ; BottomSeparator := +30 ; -RightEdge := +4 ; Bottom := +40 ; - -Margin := LeftMargin ; % obsolete -Edge := LeftEdge ; % obsolete -InnerMargin := RightMargin ; % obsolete -InnerEdge := RightEdge ; % obsolete -OuterMargin := LeftMargin ; % obsolete -OuterEdge := LeftEdge ; % obsolete - -InnerMarginWidth := 0pt ; -OuterMarginWidth := 0pt ; -InnerMarginDistance := 0pt ; -OuterMarginDistance := 0pt ; - -InnerEdgeWidth := 0pt ; -OuterEdgeWidth := 0pt ; -InnerEdgeDistance := 0pt ; -OuterEdgeDistance := 0pt ; - -path Area [][] ; pair Location [][] ; path Field [][] ; path Page ; -numeric HorPos ; numeric Hstep [] ; numeric Hsize [] ; -numeric VerPos ; numeric Vstep [] ; numeric Vsize [] ; - -for VerPos=Top step 10 until Bottom: - for HorPos=LeftEdge step 1 until RightEdge: - Area[HorPos][VerPos] := origin--cycle ; - Area[VerPos][HorPos] := Area[HorPos][VerPos] ; - Location[HorPos][VerPos] := origin ; - Location[VerPos][HorPos] := Location[HorPos][VerPos] ; - Field[HorPos][VerPos] := origin--cycle ; - Field[VerPos][HorPos] := Field[HorPos][VerPos] ; - endfor ; -endfor ; - -% def LoadPageState = -% scantokens "input mp-state.tmp" ; -% enddef ; - -def SwapPageState = - if not OnRightPage : - BackSpace := PaperWidth-MakeupWidth-BackSpace ; - CutSpace := PaperWidth-MakeupWidth-CutSpace ; - i := LeftMarginWidth ; - LeftMarginWidth := RightMarginWidth ; - RightMarginWidth := i ; - i := LeftMarginDistance ; - LeftMarginDistance := RightMarginDistance ; - RightMarginDistance := i ; - i := LeftEdgeWidth ; - LeftEdgeWidth := RightEdgeWidth ; - RightEdgeWidth := i ; - i := LeftEdgeDistance ; - LeftEdgeDistance := RightEdgeDistance ; - RightEdgeDistance := i ; - -% these are now available as ..Width and ..Distance - - Margin := LeftMargin ; - Edge := LeftEdge ; - InnerMargin := RightMargin ; - InnerEdge := RightEdge ; - OuterMargin := LeftMargin ; - OuterEdge := LeftEdge ; - else : - Margin := RightMargin ; - Edge := RightEdge ; - InnerMargin := LeftMargin ; - InnerEdge := LeftEdge ; - OuterMargin := RightMargin ; - OuterEdge := RightEdge ; - fi ; -enddef ; - -def SetPageAreas = - - numeric Vsize[], Hsize[], Vstep[], Hstep[] ; - - Vsize[Top] = TopHeight ; - Vsize[TopSeparator] = TopDistance ; - Vsize[Header] = HeaderHeight ; - Vsize[HeaderSeparator] = HeaderDistance ; - Vsize[Text] = TextHeight ; - Vsize[FooterSeparator] = FooterDistance ; - Vsize[Footer] = FooterHeight ; - Vsize[BottomSeparator] = BottomDistance ; - Vsize[Bottom] = BottomHeight ; - - Vstep[Top] = Vstep[TopSeparator] +Vsize[TopSeparator] ; - Vstep[TopSeparator] = PaperHeight-TopSpace ; - Vstep[Header] = Vstep[TopSeparator] -Vsize[Header] ; - Vstep[HeaderSeparator] = Vstep[Header] -Vsize[HeaderSeparator] ; - Vstep[Text] = Vstep[HeaderSeparator]-Vsize[Text] ; - Vstep[FooterSeparator] = Vstep[Text] -Vsize[FooterSeparator] ; - Vstep[Footer] = Vstep[FooterSeparator]-Vsize[Footer] ; - Vstep[BottomSeparator] = Vstep[Footer] -Vsize[BottomSeparator] ; - Vstep[Bottom] = Vstep[BottomSeparator]-Vsize[Bottom] ; - - Hsize[LeftEdge] = LeftEdgeWidth ; - Hsize[LeftEdgeSeparator] = LeftEdgeDistance ; - Hsize[LeftMargin] = LeftMarginWidth ; - Hsize[LeftMarginSeparator] = LeftMarginDistance ; - Hsize[Text] = MakeupWidth ; - Hsize[RightMarginSeparator] = RightMarginDistance ; - Hsize[RightMargin] = RightMarginWidth ; - Hsize[RightEdgeSeparator] = RightEdgeDistance ; - Hsize[RightEdge] = RightEdgeWidth ; - - Hstep[LeftEdge] = Hstep[LeftEdgeSeparator] -Hsize[LeftEdge] ; - Hstep[LeftEdgeSeparator] = Hstep[LeftMargin] -Hsize[LeftEdgeSeparator] ; - Hstep[LeftMargin] = Hstep[LeftMarginSeparator] -Hsize[LeftMargin] ; - Hstep[LeftMarginSeparator] = Hstep[Text] -Hsize[LeftMarginSeparator] ; - Hstep[Text] = BackSpace ; - Hstep[RightMarginSeparator] = Hstep[Text] +Hsize[Text] ; - Hstep[RightMargin] = Hstep[RightMarginSeparator]+Hsize[RightMarginSeparator] ; - Hstep[RightEdgeSeparator] = Hstep[RightMargin] +Hsize[RightMargin] ; - Hstep[RightEdge] = Hstep[RightEdgeSeparator] +Hsize[RightEdgeSeparator] ; - - for VerPos=Top step 10 until Bottom: - for HorPos=LeftEdge step 1 until RightEdge: - Area[HorPos][VerPos] := unitsquare xscaled Hsize[HorPos] yscaled Vsize[VerPos] ; - Area[VerPos][HorPos] := Area[HorPos][VerPos] ; - Location[HorPos][VerPos] := (Hstep[HorPos],Vstep[VerPos]) ; - Location[VerPos][HorPos] := Location[HorPos][VerPos] ; - Field[HorPos][VerPos] := Area[HorPos][VerPos] shifted Location[HorPos][VerPos] ; - Field[VerPos][HorPos] := Field[HorPos][VerPos] ; - endfor ; - endfor ; - - Page := unitsquare xscaled PaperWidth yscaled PaperHeight ; - -enddef ; - -def BoundPageAreas = - - % pickup pencircle scaled 0pt ; - - bboxmargin := 0 ; setbounds currentpicture to Page ; - -enddef ; - -def StartPage = - - if PageStateAvailable : - LoadPageState ; - SwapPageState ; - fi ; - - SetPageAreas ; - BoundPageAreas ; - -enddef ; - -def StopPage = - - BoundPageAreas ; - -enddef ; - -def OverlayBox = - (unitsquare xyscaled (OverlayWidth,OverlayHeight)) -enddef ; - -% handy - -def innerenlarged = - hide(LoadPageState) - if OnRightPage : leftenlarged else : rightenlarged fi -enddef ; - -def outerenlarged = - hide(LoadPageState) - if OnRightPage : rightenlarged else : leftenlarged fi -enddef ; - -% obsolete - -def llEnlarged (expr p,d) = (llcorner p shifted (-d,-d)) enddef ; -def lrEnlarged (expr p,d) = (lrcorner p shifted (+d,-d)) enddef ; -def urEnlarged (expr p,d) = (urcorner p shifted (+d,+d)) enddef ; -def ulEnlarged (expr p,d) = (ulcorner p shifted (-d,+d)) enddef ; - -def Enlarged (expr p, d) = - (llEnlarged (p,d) -- - lrEnlarged (p,d) -- - urEnlarged (p,d) -- - ulEnlarged (p,d) -- cycle) -enddef ; - -endinput ; diff --git a/metapost/context/mp-shap.mp b/metapost/context/mp-shap.mp deleted file mode 100644 index 0f5fe431d..000000000 --- a/metapost/context/mp-shap.mp +++ /dev/null @@ -1,307 +0,0 @@ -%D \module -%D [ file=mp-shap.mp, -%D version=2000.05.31, -%D title=\CONTEXT\ \METAPOST\ graphics, -%D subtitle=shapes, -%D author=Hans Hagen, -%D date=\currentdate, -%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] -%C -%C This module is part of the \CONTEXT\ macro||package and is -%C therefore copyrighted by \PRAGMA. See licen-en.pdf for -%C details. - -if unknown context_tool : input mp-tool ; fi ; -if known context_shap : endinput ; fi ; - -boolean context_shap ; context_shap := true ; - -vardef some_shape_path (expr type) = - - begingroup ; - - save border, xradius, yradius, - normal, mirror, rotate, - lc, rc, tc, bc, ll, lr, ur, ul, - llx, lrx, urx, ulx, lly, lry, ury, uly ; - - path border ; - - xradius := .15 ; xxradius := .10 ; - yradius := .15 ; yyradius := .10 ; - - pair ll ; ll := llcorner (unitsquare shifted (-.5,-.5)) ; - pair lr ; lr := lrcorner (unitsquare shifted (-.5,-.5)) ; - pair ur ; ur := urcorner (unitsquare shifted (-.5,-.5)) ; - pair ul ; ul := ulcorner (unitsquare shifted (-.5,-.5)) ; - - pair llx ; llx := ll shifted (xradius,0) ; - pair lly ; lly := ll shifted (0,yradius) ; - - pair lrx ; lrx := lr shifted (-xradius,0) ; - pair lry ; lry := lr shifted (0,yradius) ; - - pair urx ; urx := ur shifted (-xradius,0) ; - pair ury ; ury := ur shifted (0,-yradius) ; - - pair ulx ; ulx := ul shifted (xradius,0) ; - pair uly ; uly := ul shifted (0,-yradius) ; - - pair llxx ; llxx := ll shifted (xxradius,0) ; - pair llyy ; llyy := ll shifted (0,yyradius) ; - - pair lrxx ; lrxx := lr shifted (-xxradius,0) ; - pair lryy ; lryy := lr shifted (0,yyradius) ; - - pair urxx ; urxx := ur shifted (-xxradius,0) ; - pair uryy ; uryy := ur shifted (0,-yyradius) ; - - pair ulxx ; ulxx := ul shifted (xxradius,0) ; - pair ulyy ; ulyy := ul shifted (0,-yyradius) ; - - pair lc ; lc := ll shifted (0,.5) ; - pair rc ; rc := lr shifted (0,.5) ; - pair tc ; tc := ul shifted (.5,0) ; - pair bc ; bc := ll shifted (.5,0) ; - - def mirror (expr p) = - p rotatedaround(origin,180) - enddef ; - - def normal (expr p ) = - p - enddef ; - - def rotate (expr p) = - p rotated 45 - enddef ; - - if type= 0 : - border := normal (origin--cycle) ; - - elseif type= 5 : - border := normal (llx--lrx{right}...rc...{left}urx--ulx{left}...lc...{right}cycle) ; - elseif type= 6 : - border := normal (ll--lrx{right}...rc...{left}urx--ul--cycle) ; - elseif type= 7 : - border := mirror (ll--lrx{right}...rc...{left}urx--ul--cycle) ; - elseif type= 8 : - border := normal (lr--ury{up}...tc...{down}uly--ll--cycle) ; - elseif type= 9 : - border := mirror (lr--ury{up}...tc...{down}uly--ll--cycle) ; - elseif type=10 : - border := normal (ll--lr--ur--ul--ll--ur--ul--ll--cycle) ; - elseif type=11 : - border := normal (ll--lr--ur--ul--ll--lr--ul--ll--cycle) ; - elseif type=12 : - border := normal (ll--lrx--ur--ulx--cycle) ; - elseif type=13 : - border := normal (llx--lr--urx--ul--cycle) ; - elseif type=14 : - border := normal (lly--bc--lry--ury--tc--uly--cycle) ; - elseif type=15 : - border := normal (llx--lrx--rc--urx--ulx--lc--cycle) ; - elseif type=16 : - border := normal (ll--lrx--rc--urx--ul--cycle) ; - elseif type=17 : - border := mirror (ll--lrx--rc--urx--ul--cycle) ; - elseif type=18 : - border := normal (lr--ury--tc--uly--ll--cycle) ; - elseif type=19 : - border := mirror (lr--ury--tc--uly--ll--cycle) ; - elseif type=20 : - border := normal (ll--lr--ur--ul--ll--llxx--ulxx--ul--ll-- - lr--ur--urxx--lrxx--cycle) ; - elseif type=21 : - border := normal (ul--ll--lr--ur--ul--ulyy--uryy--ur--ul-- - ll--lr--lryy--llyy--cycle) ; - elseif type=22 : - border := normal (ll--lrx--lry--ur--ulx--uly--cycle) ; - elseif type=23 : - border := normal (llx--lr--ury--urx--ul--lly--cycle) ; - elseif type=24 : - border := normal (ll--lr--ur--ul--cycle) ; - elseif type=25 : - border := normal (llx--lrx--lry--ury--urx--ulx--uly--lly--cycle) ; - elseif type=26 : - border := normal (ll--lrx--lry--ur--ul--cycle) ; - elseif type=27 : - border := mirror (ll--lr--ury--urx--ul--cycle) ; - elseif type=28 : - border := normal (ll--lr--ury--urx--ul--cycle) ; - elseif type=29 : - border := mirror (ll--lrx--lry--ur--ul--cycle) ; - elseif type=30 : - border := rotate (bc{right}...{up}rc...tc{left}...{down}lc...{right}bc & - bc--tc & tc{left}..{down}lc & lc--rc & - rc{up}..tc{left}...{down}lc...{right}bc & cycle) ; - elseif type=31 : - border := normal (bc{right}...{up}rc...tc{left}...{down}lc...{right}bc & - bc--tc & tc{left}..{down}lc & lc--rc & - rc{up}..tc{left}...{down}lc...{right}bc & cycle) ; - elseif type=32 : - border := normal (ll{right}...{right}lry--ur--ul--ll--cycle) ; - elseif type=33 : - border := normal (ll{right}...{right}lry--ur--ul--ll--cycle - --ul--ulx--ulx shifted(0,yyradius) - --ur shifted(yyradius,yyradius) - --lry shifted(yyradius,yyradius) - --lry shifted(0,yyradius) - --ur--ul--cycle ) ; - elseif type=34 : - border := normal (uly..tc..ury & - ury..tc shifted (0,-2yradius)..uly & - uly--lly & - lly..bc..lry & - lry--ury & - ury..tc shifted (0,-2yradius)..uly & cycle ) ; - elseif type=35 : - border := normal (bc{right}...rc{up}...tc{left}...lc{down}...cycle) ; - elseif type=36 : - border := normal (ul--tc{right}..rc{down}..{left}bc--ll & - ll..(xpart llx, ypart lc)..ul & cycle) ; - elseif type=37 : - border := mirror (ul--tc{right}..rc{down}..{left}bc--ll & - ll..(xpart llx, ypart lc)..ul & cycle) ; - elseif type=38 : - border := normal (ll--lc{up}..tc{right}..{down}rc--lr & - lr..(xpart bc, ypart lly)..ll & cycle) ; - elseif type=39 : - border := mirror (ll--lc{up}..tc{right}..{down}rc--lr & - lr..(xpart bc, ypart lly)..ll & cycle) ; - elseif type=40 : - border := normal (ll--lr--ur--ul--ll--ur--ul--ll--lr--ul--ll--cycle) ; - elseif type=41 : - border := normal (ll--lr--ur--ul--ll--lr--rc--lc--ll--bc--tc--ul--ll & cycle) ; - elseif type=42 : - border := normal (ll--lr--origin shifted (+epsilon,0)-- - ur--ul--origin shifted (-epsilon,0)--cycle) ; - elseif type=43 : - border := normal (ll--ul--origin shifted (0,+epsilon)-- - ur--lr--origin shifted (0,-epsilon)--cycle) ; - elseif type=45 : - border := normal (bc--rc--tc--lc--cycle) ; - elseif type=46 : - border := normal (ll--ul--rc--cycle) ; - elseif type=47 : - border := mirror (ll--ul--rc--cycle) ; - elseif type=48 : - border := mirror (ul--ur--bc--cycle) ; - elseif type=49 : - border := normal (ul--ur--bc--cycle) ; - - elseif type=56 : - border := normal (ll--lry--ury--ul--cycle) ; - elseif type=57 : - border := mirror (ll--lry--ury--ul--cycle) ; - elseif type=58 : - border := normal (ll--ulx--urx--lr--cycle) ; - elseif type=59 : - border := mirror (ll--ulx--urx--lr--cycle) ; - - elseif type=61 : - border := normal (fullcircle scaled (1.5*yradius) xscaled (grid_height/grid_width)) ; - elseif type=62 : - border := normal (fullcircle scaled (2.0*yradius) xscaled (grid_height/grid_width)) ; - - elseif type=66 : - border := normal (rc--origin shifted ( epsilon,0) --cycle & - rc--origin --cycle ) ; - elseif type=67 : - border := normal (lc--origin shifted (-epsilon,0) --cycle & - lc--origin --cycle ) ; - elseif type=68 : - border := normal (tc--origin shifted (0, epsilon) --cycle & - tc--origin --cycle ) ; - elseif type=69 : - border := normal (bc--origin shifted (0,-epsilon) --cycle & - bc--origin --cycle ) ; - - elseif type=75 : - border := mirror (lly--lry--ury--uly--cycle) ; - elseif type=76 : - border := mirror (ll--lr--ur--uly--cycle) ; - elseif type=77 : - border := mirror (ll--lr--ury--ul--cycle) ; - elseif type=78 : - border := mirror (lly--lr--ur--ul--cycle) ; - elseif type=79 : - border := mirror (ll--lry--ur--ul--cycle) ; - - else : - border := normal (origin--cycle) ; - %border := normal (ll--lr--ur--ul--cycle) ; - fi ; - - border - - endgroup - -enddef; - -def some_shape ( expr shape_type , - shape_width , - shape_height , - shape_linewidth , - shape_linecolor , - shape_fillcolor ) = - - path p ; p := - some_shape_path (shape_type) - xscaled shape_width - yscaled shape_height ; - - pickup pencircle scaled shape_linewidth ; - - fill p withcolor shape_fillcolor ; - draw p withcolor shape_linecolor ; - -enddef ; - -vardef drawshape (expr t, p, lw, lc, fc) = - save pp ; - if t>1 : % normal shape - path pp ; - pp := some_shape_path(t) xyscaled(bbwidth(p), bbheight(p)) shifted center p ; - fill pp withcolor fc ; - draw pp withpen pencircle scaled lw withcolor lc ; - elseif t=1 : % background only - path pp ; - pp := fullsquare xyscaled(bbwidth(p), bbheight(p)) shifted center p ; - fill pp withcolor fc ; - else : % dimensions only - picture pp ; pp := nullpicture ; - setbounds pp to fullsquare xyscaled(bbwidth(p), bbheight(p)) shifted center p ; - draw pp ; - fi ; -enddef ; - -vardef drawline (expr t, p, lw, lc) = - if (t>0) and (length(p)>1) : - saveoptions ; - drawoptions(withpen pencircle scaled lw withcolor lc) ; - draw p ; - if t = 1 : - draw arrowheadonpath(p,1) ; - elseif t = 2 : - draw arrowheadonpath(reverse p,1) ; - elseif t = 3 : - for $ = p,reverse p : draw arrowheadonpath($,1) ; endfor ; - elseif t = 11 : - draw arrowheadonpath(p,1/2) ; - elseif t = 12 : - draw arrowheadonpath(reverse p,1/2) ; - elseif t = 13 : - for $=p,reverse p : draw arrowheadonpath($,1) ; endfor ; - for $=p,reverse p : draw arrowheadonpath($,3/4) ; endfor ; - elseif t = 21 : - for $=1/5,1/2,4/5 : draw arrowheadonpath(p,$) ; endfor ; - elseif t = 22 : - for $=1/5,1/2,4/5 : draw arrowheadonpath(reverse p,$) ; endfor ; - elseif t = 23 : - for $=p,reverse p : draw arrowheadonpath($,1/4) ; endfor ; - fi ; - fi ; -enddef ; - -endinput ; diff --git a/metapost/context/mp-spec.mp b/metapost/context/mp-spec.mp deleted file mode 100644 index 10118f2c0..000000000 --- a/metapost/context/mp-spec.mp +++ /dev/null @@ -1,555 +0,0 @@ -%D \module -%D [ file=mp-spec.mp, -%D version=1999.6.26, -%D title=\CONTEXT\ \METAPOST\ graphics, -%D subtitle=special extensions, -%D author=Hans Hagen, -%D date=\currentdate, -%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] -%C -%C This module is part of the \CONTEXT\ macro||package and is -%C therefore copyrighted by \PRAGMA. See licen-en.pdf for -%C details. - -% Spot colors are not handled by mptopdf ! - -% (r,g,b) => cmyk : r=123 g= 1 b=hash -% => spot : r=123 g= 2 b=hash -% => transparent rgb : r=123 g= 3 b=hash -% => transparent cmyk : r=123 g= 4 b=hash -% => transparent spot : r=123 g= 5 b=hash -% => rest : r=123 g=n>10 b=whatever - -%D This module is rather preliminary and subjected to -%D changes. Here we closely cooperates with the \METAPOST\ -%D to \PDF\ converter module built in \CONTEXT\ and provides -%D for instance shading. More information can be found in -%D type {supp-mpe.tex}. - -if unknown context_tool : input mp-tool ; fi ; -if known context_spec : endinput ; fi ; - -boolean context_spec ; context_spec := true ; - -numeric _special_counter_ ; _special_counter_ := 0 ; -numeric _color_counter_ ; _color_counter_ := 11 ; % < 10 reserved -numeric _special_signal_ ; _special_signal_ := 123 ; - -%D When set to \type {true}, shading will be supported. Some -%D day I will also write an additional directive. - -boolean _inline_specials_ ; _inline_specials_ := false ; - -%D Because we want to output only those specials that are -%D actually used in a figure, we need a bit complicated -%D bookkeeping and collection of specials. At the cost of some -%D obscurity, we now have rather efficient resources. - -string _global_specials_ ; _global_specials_ := "" ; -string _local_specials_ ; _local_specials_ := "" ; - -vardef add_special_signal = % write the version number - if (length _global_specials_>0) or (length _local_specials_ >0) : - special ("%%MetaPostSpecials: 1.0 " & decimal _special_signal_ ) ; - fi ; -enddef ; - -vardef add_extra_specials = - scantokens _global_specials_ ; - scantokens _local_specials_ ; -enddef ; - -vardef reset_extra_specials = - % only local ones - _local_specials_ := "" ; -enddef ; - -boolean insidefigure ; insidefigure := false ; - -% todo: alleen als special gebruikt flush - -extra_beginfig := - " insidefigure := true ; " & - " reset_extra_specials ; " & - extra_beginfig ; - -extra_endfig := - " add_special_signal ; " & - extra_endfig & - " add_extra_specials ; " & - " reset_extra_specials ; " & - " insidefigure := false ; " ; - -def set_extra_special (expr s) = - if insidefigure : - _local_specials_ := _local_specials_ & s ; - else : - _global_specials_ := _global_specials_ & s ; - fi -enddef ; - -def flush_special (expr typ, siz, dat) = - _special_counter_ := _special_counter_ + 1 ; - if _inline_specials_ : - set_extra_special - ( "special " - & "(" & ditto - & dat & " " - & decimal _special_counter_ & " " - & decimal typ & " " - & decimal siz - & " special" - & ditto & ");" ) ; - else : - set_extra_special - ( "special " - & "(" & ditto - & "%%MetaPostSpecial: " - & decimal siz & " " - & dat & " " - & decimal _special_counter_ & " " - & decimal typ - & ditto & ");" ) ; - fi ; -enddef ; - -%D The next hack is needed in case you use a version of -%D \METAPOST\ that does not provide you the means to configure -%D the buffer size. Patrick Gundlach suggested to use arrays -%D in this case. - -boolean bufferhack ; bufferhack := false ; % true ; - -if bufferhack : - - string _global_specials_[] ; numeric _nof_global_specials_ ; - string _local_specials_[] ; numeric _nof_local_specials_ ; - - _nof_global_specials_ := _nof_local_specials_ := 0 ; - - vardef add_special_signal = % write the version number - if (_nof_global_specials_>0) or (_nof_local_specials_>0) : - special ("%%MetaPostSpecials: 1.0 " & decimal _special_signal_ ) ; - fi ; - enddef ; - - vardef add_extra_specials = - for i=1 upto _nof_global_specials_ : - scantokens _global_specials_[i] ; - endfor; - for i=1 upto _nof_local_specials_ : - scantokens _local_specials_[i] ; - endfor; - enddef ; - - vardef reset_extra_specials = - string _local_specials_[] ; _nof_local_specials_ := 0 ; - enddef ; - - def set_extra_special (expr s) = - if insidefigure : - _local_specials_[incr(_nof_local_specials_)] := s ; - else : - _global_specials_[incr(_nof_global_specials_)] := s ; - fi - enddef ; - -fi ; - -%D So far for this hack. - -%D Shade allocation. - -newinternal shadefactor ; shadefactor := 1 ; - -pair shadeoffset ; shadeoffset := origin ; - -vardef define_linear_shade (expr a, b, ca, cb) = - flush_special(30, 15, "0 1 " & decimal shadefactor & " " & - dddecimal ca & " " & ddecimal (a shifted shadeoffset) & " " & - dddecimal cb & " " & ddecimal (b shifted shadeoffset) ) ; - _special_counter_ -enddef ; - -vardef define_circular_shade (expr a, b, ra, rb, ca, cb) = - flush_special(31, 17, "0 1 " & decimal shadefactor & " " & - dddecimal ca & " " & ddecimal (a shifted shadeoffset) & " " & decimal ra & " " & - dddecimal cb & " " & ddecimal (b shifted shadeoffset) & " " & decimal rb ) ; - _special_counter_ -enddef ; - -%D A few predefined shading macros. - -boolean trace_shades ; trace_shades := false ; - -% if (n=1) : a := llcorner p ; b := urcorner p ; -% elseif (n=2) : a := llcorner p ; b := ulcorner p ; -% elseif (n=3) : a := lrcorner p ; b := ulcorner p ; -% else : a := llcorner p ; b := lrcorner p ; -% fi ; - -def set_linear_vector (suffix a,b)(expr p,n) = - if (n=1) : a := llcorner p ; - b := urcorner p ; - elseif (n=2) : a := lrcorner p ; - b := ulcorner p ; - elseif (n=3) : a := urcorner p ; - b := llcorner p ; - elseif (n=4) : a := ulcorner p ; - b := lrcorner p ; - elseif (n=5) : a := .5[ulcorner p,llcorner p] ; - b := .5[urcorner p,lrcorner p] ; - elseif (n=6) : a := .5[llcorner p,lrcorner p] ; - b := .5[ulcorner p,urcorner p] ; - elseif (n=7) : a := .5[lrcorner p,urcorner p] ; - b := .5[llcorner p,ulcorner p] ; - elseif (n=8) : a := .5[urcorner p,ulcorner p] ; - b := .5[lrcorner p,llcorner p] ; - else : a := .5[ulcorner p,llcorner p] ; - b := .5[urcorner p,lrcorner p] ; - fi ; -enddef ; - -def linear_shade (expr p, n, ca, cb) = - begingroup ; - save a, b, sh ; pair a, b ; - set_linear_vector(a,b)(p,n) ; - fill p withshade define_linear_shade (a,b,ca,cb) ; - if trace_shades : - drawarrow a -- b withpen pencircle scaled 1pt ; - fi ; - endgroup ; -enddef ; - -vardef predefined_linear_shade (expr p, n, ca, cb) = - save a, b, sh ; pair a, b ; - set_linear_vector(a,b)(p,n) ; - set_shade_vector(a,b)(p,n) ; - define_linear_shade (a,b,ca,cb) -enddef ; - -def set_circular_vector (suffix ab, r)(expr p,n) = - if (n=1) : ab := llcorner p ; - elseif (n=2) : ab := lrcorner p ; - elseif (n=3) : ab := urcorner p ; - elseif (n=4) : ab := ulcorner p ; - else : ab := center p ; r := .5r ; - fi ; -enddef ; - -def circular_shade (expr p, n, ca, cb) = - begingroup ; - save ab, r ; pair ab ; numeric r ; - r := (xpart lrcorner p - xpart llcorner p) ++ - (ypart urcorner p - ypart lrcorner p) ; - set_circular_vector(ab,r)(p,n) ; - fill p withshade define_circular_shade(ab,ab,0,r,ca,cb) ; - if trace_shades : - drawarrow ab -- ab shifted (0,r) withpen pencircle scaled 1pt ; - fi ; - endgroup ; -enddef ; - -vardef predefined_circular_shade (expr p, n, ca, cb) = - save ab, r ; pair ab ; numeric r ; - r := (xpart lrcorner p - xpart llcorner p) ++ - (ypart urcorner p - ypart lrcorner p) ; - set_circular_vector(ab,r)(p,n) ; - define_circular_shade(ab,ab,0,r,ca,cb) -enddef ; - -%D Since a \type {fill p withshade s} syntax looks better -%D than some macro, we implement a new primary. - -primarydef p withshade sc = % == p withcolor shadecolor(sh) - hide (_color_counter_ := _color_counter_ + 1) - p withcolor (_special_signal_/1000,_color_counter_/1000,sc/1000) -enddef ; - -vardef shadecolor(expr sc) = - hide (_color_counter_ := _color_counter_ + 1) - (_special_signal_/1000,_color_counter_/1000,sc/1000) -enddef ; - -%D Figure inclusion. - -%numeric cef ; cef := 0 ; - -def externalfigure primary filename = - doexternalfigure (filename) -enddef ; - -def doexternalfigure (expr filename) text transformation = - begingroup ; save p, t ; picture p ; transform t ; - p := nullpicture ; t := identity transformation ; - flush_special(10, 9, - dddecimal (xxpart t, yxpart t, xypart t) & " " & - dddecimal (yypart t, xpart t, ypart t) & " " & filename) ; - addto p contour unitsquare scaled 0 ; - setbounds p to unitsquare transformed t ; - _color_counter_ := _color_counter_ + 1 ; - draw p withcolor (_special_signal_/1000,_color_counter_/1000,_special_counter_/1000) ; -%draw p withcolor (_special_signal_/1000,cef/1000,_special_counter_/1000) ; - endgroup ; -enddef ; - -%D Experimental: - -%numeric currenthyperlink ; currenthyperlink := 0 ; - -def hyperlink primary t = dohyperlink(t) enddef ; -def hyperpath primary t = dohyperpath(t) enddef ; - -def dohyperlink (expr destination) text transformation = - begingroup ; save somepath ; path somepath ; - somepath := fullsquare transformation ; - dohyperpath(destination) somepath ; - endgroup ; -enddef ; - -def dohyperpath (expr destination) expr somepath = - begingroup ; - flush_special(20, 7, - ddecimal (xpart llcorner somepath, ypart llcorner somepath) & " " & - ddecimal (xpart urcorner somepath, ypart urcorner somepath) & " " & destination) ; -% currenthyperlink := currenthyperlink + 1 ; - _color_counter_ := _color_counter_ + 1 ; - fill boundingbox unitsquare scaled 0 withcolor - (_special_signal_/1000,_color_counter_/1000,_special_counter_/1000) ; -% (_special_signal_/1000,currenthyperlink/1000,_special_counter_/1000) ; - endgroup ; -enddef ; - -% \setupinteraction[state=start] -% \setupcolors [state=start] -% -% Hello There! \blank -% -% \startMPcode -% pickup pencircle scaled 5 ; -% draw fullcircle scaled 4cm withcolor red ; -% hyperpath "nextpage" boundingbox currentpicture ; -% draw origin withcolor blue ; -% \stopMPcode -% -% \blank Does it work or not? -% -% \startMPcode -% pickup pencircle scaled 5 ; -% draw fullcircle scaled 4cm withcolor red ; -% hyperpath "nextpage" fullcircle scaled 4cm ; -% draw origin withcolor blue ; -% draw fullcircle scaled 4cm shifted (1cm,1cm); -% \stopMPcode -% -% \blank Does it work or not? \page Hello There! \blank -% -% \startMPcode -% pickup pencircle scaled 5 ; -% draw fullcircle scaled 2cm shifted (-2cm,-1cm) ; -% draw fullcircle scaled 3cm shifted (2cm,1cm) withcolor red ; -% draw fullcircle scaled 1cm ; -% hyperlink "previouspage" scaled 3cm shifted (2cm,1cm) ; -% draw origin withcolor blue ; -% \stopMPcode -% -% \blank Does it work or not? - -_cmyk_counter_ := 0 ; - -extra_endfig := " resetcmykcolors ; " & extra_endfig ; - -def resetcmykcolors = - numeric cmykcolorhash[][][][] ; -enddef ; - -resetcmykcolors ; boolean cmykcolors ; cmykcolors := false ; % true - -string cmykcolorpattern[] ; % needed for transparancies - -vardef cmyk(expr c,m,y,k) = - if cmykcolors : - save ok ; boolean ok ; - if unknown cmykcolorhash[c][m][y][k] : - ok := false ; % not yet defined - elseif cmykcolorhash[c][m][y][k] = -1 : - ok := false ; % locally defined and undefined - else : - ok := true ; % globally already defined - fi ; - if not ok : - save s ; string s ; s := dddecimal (c,m,y) & " " & decimal k ; - _cmyk_counter_ := _cmyk_counter_ + 1 ; - cmykcolorpattern[_cmyk_counter_/1000] := s ; - cmykcolorhash[c][m][y][k] := _cmyk_counter_ ; - flush_special(1, 7, decimal _cmyk_counter_ & " " & s) ; - _local_specials_ := _local_specials_ & - " cmykcolorhash[" & decimal c & "][" & decimal m & - "][" & decimal y & "][" & decimal k & "] := -1 ; " ; - fi ; - (_special_signal_/1000,1/1000,cmykcolorhash[c][m][y][k]/1000) - else : - (1-c-k,1-m-k,1-y-k) - fi -enddef ; - -% newcolor truecyan, truemagenta, trueyellow ; -% -% truecyan = cmyk (1,0,0,0) ; -% truemagenta = cmyk (0,1,0,0) ; -% trueyellow = cmyk (0,0,1,0) ; - -%D Spot colors - -_spotcolor_counter_ := 0 ; -_spotcolor_number_ := 0 ; - -extra_endfig := " resetspotcolors ; " & extra_endfig ; - -def resetspotcolors = - numeric spotcolorhash[][] ; -enddef ; - -resetspotcolors ; boolean spotcolors ; spotcolors := false ; % true - -string spotcolorpattern[] ; % needed for transparancies - -vardef spotcolor(expr p, s) = - if spotcolors : - save ok, pc_tag ; boolean ok ; string pc_tag ; - pc_tag := "_pct_"&p ; - if not unstringed(pc_tag) : - _spotcolor_number_ := _spotcolor_number_ + 1 ; - setunstringed(pc_tag,_spotcolor_number_) ; - fi ; - pp := getunstringed(pc_tag) ; - if unknown spotcolorhash[pp][s] : - ok := false ; % not yet defined - elseif spotcolorhash[pp][s] = -1 : - ok := false ; % locally defined and undefined - else : - ok := true ; % globally already defined - fi ; - if not ok : - save ss ; string ss ; ss := p & " " & decimal s ; - _spotcolor_counter_ := _spotcolor_counter_ + 1 ; - spotcolorpattern[_spotcolor_counter_/1000] := ss ; - spotcolorhash[pp][s] := _spotcolor_counter_ ; - flush_special(2, 5, decimal _spotcolor_counter_ & " " & ss) ; - _local_specials_ := _local_specials_ & - "spotcolorhash["&decimal pp&"]["&decimal s&"]:=-1;" ; - fi ; - (_special_signal_/1000,2/1000,spotcolorhash[pp][s]/1000) - else : - (1-s,1-s,1-s) - fi -enddef ; - -%D Transparency - -normaltransparent := 1 ; multiplytransparent := 2 ; -screentransparent := 3 ; overlaytransparent := 4 ; -softlighttransparent := 5 ; hardlighttransparent := 6 ; -colordodgetransparent := 7 ; colorburntransparent := 8 ; -darkentransparent := 9 ; lightentransparent := 10 ; -differencetransparent := 11 ; exclusiontransparent := 12 ; - -% nottransparent := 0 ; -% compatibletransparent := 99 ; - -% fill fullcircle scaled 10cm withcolor transparant(.8,3,color) ; - -vardef transparent(expr n, t, c) = - save s, ss, nn, cc, is_cmyk, is_spot, ok ; - string s, ss ; numeric nn ; color cc ; boolean is_cmyk, is_spot, ok ; - % transparancy type - if string n : - if expandafter known scantokens(n&"transparent") : - nn := scantokens(n&"transparent") ; - else : - nn := 0 ; - fi - else : % nn := min(n,13) - nn := if n<13 : n else : nn := 0 fi ; - fi ; - % we need to expand the color (can be cmyk(..) or predefined) - cc := c ; % expand color - % check for cmyk special - is_cmyk := (redpart cc = _special_signal_/1000) - and (greenpart cc = 1/1000) ; - is_spot := (redpart cc = _special_signal_/1000) - and (greenpart cc = 2/1000) ; - % build special string, fetch cmyk components - s := decimal nn & " " & decimal t & " " & - if is_cmyk : cmykcolorpattern[bluepart cc] - elseif is_spot : spotcolorpattern[bluepart cc] - else : dddecimal cc fi ; - % check if this one is already used - ss := "tr_" & s ; - % efficiency hack - if expandafter unknown scantokens(ss) : - ok := false ; % not yet defined - elseif scantokens(ss) < 0 : - ok := false ; % locally defined and undefined - else : - ok := true ; % globally already defined - fi ; - if not ok : - if is_spot : - flush_special(5, 6, s) ; - elseif is_cmyk : - flush_special(4, 8, s) ; - else : - flush_special(3, 7, s) ; - fi ; - scantokens(ss) := _special_counter_ ; - _local_specials_ := _local_specials_ & - "scantokens(" & ditto & ss & ditto & ") := -1 ;" ; - fi ; - % go ahead - if is_spot : - (_special_signal_/1000,5/1000,scantokens(ss)/1000) - elseif is_cmyk : - (_special_signal_/1000,4/1000,scantokens(ss)/1000) - else : - (_special_signal_/1000,3/1000,scantokens(ss)/1000) - fi -enddef ; - -%D Basic position tracking: - -def register (expr label, width, height, offset) = - begingroup ; - flush_special(50, 7, - ddecimal offset & " " & - decimal width & " " & - decimal height & " " & label) ; - endgroup ; -enddef ; - -%D We cannot scale cmyk colors directly since this spoils -%D the trigger signal (such colors are no real colors). - -vardef scaledcmyk(expr c,m,y,k,sf) = - cmyk(sf*c,sf*m,sf*y,sf*k) -enddef ; - -vardef scaledcmykasrgb(expr c,m,y,k,sf) = - (sf*(1-c-k,1-m-k,1-y-k)) -enddef ; - -vardef scaledrgbascmyk(expr c,m,y,k,sf) = - scaledcmyk(1-c,1-m,1-y,0,sf) -enddef ; - -vardef scaledrgb(expr r,g,b,sf) = - (sf*(r,g,b)) -enddef ; - -vardef scaledgray(expr s,sf) = - (sf*(s,s,s)) -enddef ; - -% spotcolor is already scaled - -endinput ; diff --git a/metapost/context/mp-step.mp b/metapost/context/mp-step.mp deleted file mode 100644 index d602f7014..000000000 --- a/metapost/context/mp-step.mp +++ /dev/null @@ -1,320 +0,0 @@ -%D \module -%D [ file=mp-step.mp, -%D version=2001.05.22, -%D title=\CONTEXT\ \METAPOST\ graphics, -%D subtitle=steps, -%D author=Hans Hagen, -%D date=\currentdate, -%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] -%C -%C This module is part of the \CONTEXT\ macro||package and is -%C therefore copyrighted by \PRAGMA. See licen-en.pdf for -%C details. - -if unknown context_tool : input mp-tool ; fi ; -if known context_step : endinput ; fi ; - -boolean context_step ; context_step := true ; - -%D In the associated \TEX\ module \type {m-steps}, we describe -%D three methods. The first method uses a different kind of -%D code than the other two. The method we decided to use, -%D is based on positional information (paths) provided by -%D \CONTEXT. - -def initialize_step_variables = - save line_method, line_h_offset, line_v_offset ; - numeric line_method ; line_method := 1 ; - numeric line_h_offset ; line_h_offset := 3pt ; - numeric line_v_offset ; line_v_offset := 3pt ; -enddef ; - -def begin_step_chart = - initialize_step_variables ; - save steps, texts, t, b, tb, nofcells ; - picture cells[][], texts[][][], lines[][][] ; - numeric t, b ; t := 1 ; b := 2 ; - numeric nofcells ; nofcells := 0 ; -enddef ; - -def analyze_step_chart = - numeric n[], l[][], r[][] ; pair p[] ; - n[t] := n[b] := 0 ; numeric tb ; - for i=1 upto nofcells : for nn = t, b : - if bbwidth(cells[nn][i])>0 : n[nn] := n[nn] + 1 ; fi ; - l[t][i] := r[t][i] := l[b][i] := r[b][i] := 0 ; - endfor ; endfor ; - % count left and right points - for i=1 upto nofcells-1 : for j=i upto nofcells-1 : for nn = t, b : - if bbwidth(texts[nn][i][j])>0 : - l[nn][i] := l[nn][i] + 1 ; - r[nn][j+1] := r[nn][j+1] + 1 ; - fi ; - endfor ; endfor ; endfor ; - % calculate left and right points - vardef do (expr nn, mm, ii, ss) = - if (l[nn][ii] + r[nn][ii]) > 1 : ss else : .5 fi - [ ulcorner cells[mm][ii], urcorner cells[mm][ii] ] - enddef ; - % combined rows - tb := if n[t]>0 : t else : b fi ; -enddef ; - -vardef get_step_chart_top_line (expr i, j) = - if bbwidth(cells[tb][i])>0 : - if bbwidth(texts[t][i][j])>0 : - if bbwidth(cells[tb][j+1])>0 : - p[1] := top do(t, tb, i, .6) ; - p[3] := top do(t, tb, j+1, .4) ; - p[2] := .5[p[1],p[3]] ; - if line_method = 1 : - p[2] := p[2] shifted (0, ypart - (llcorner texts[t][i][j] - ulcorner cells[tb][j+1])) ; - elseif line_method = 2 : - p[2] := center texts[t][i][j] ; - else : - % nothing - fi ; - p[1] := p[1] shifted (0,+line_v_offset) ; - p[2] := p[2] shifted (0,-line_v_offset) ; - p[3] := p[3] shifted (0,+line_v_offset) ; - (p[1] {up} ... p[2] ... {down} p[3]) - else : - origin - fi - else : - origin - fi - else : - origin - fi -enddef ; - -vardef get_step_chart_bot_line (expr i, j) = - if bbwidth(cells[b][i])>0 : - if bbwidth(texts[b][i][j])>0 : - if bbwidth(cells[b][j+1])>0 : - p[1] := (bot do(b, b, i, .6)) shifted (0,-bbheight(cells[b][i])) ; - p[3] := (bot do(b, b, j+1, .4)) shifted (0,-bbheight(cells[b][j+1])) ; - p[2] := .5[p[1],p[3]] ; - if line_method = 1 : - p[2] := p[2] shifted (0, -ypart - (llcorner cells[b][j+1] - ulcorner texts[b][i][j])) ; - elseif line_method = 2 : - p[2] := center texts[b][i][j] ; - fi ; - p[1] := p[1] shifted (0,-line_v_offset) ; - p[2] := p[2] shifted (0,+line_v_offset) ; - p[3] := p[3] shifted (0,-line_v_offset) ; - (p[1] {down} ... p[2] ... {up} p[3]) - else : - origin - fi - else : - origin - fi - else : - origin - fi -enddef ; - -def end_step_chart = - for i=1 upto nofcells : for nn = t, b : - if bbwidth(cells[nn][i]) >0 : draw cells[nn][i] ; fi ; - endfor ; endfor ; - for i=1 upto nofcells : for j=i upto nofcells : for nn = t, b : - if known lines[nn][i][j] : - if bbwidth(lines[nn][i][j])>0 : draw lines[nn][i][j] ; fi ; - fi ; - endfor ; endfor ; endfor ; - for i=1 upto nofcells : for j=i upto nofcells : for nn = t, b : - if bbwidth(texts[nn][i][j])>0 : draw texts[nn][i][j] ; fi ; - endfor ; endfor ; endfor ; -enddef ; - -%D Step tables. - -def begin_step_table = - initialize_step_variables ; - picture cells[], texts[], lines[] ; - numeric nofcells ; nofcells := 0 ; -enddef ; - -def end_step_table = - for i=1 upto nofcells : if known cells[i] : if bbwidth(cells[i])>0 : - draw cells[i] ; - fi ; fi ; endfor ; - for i=1 upto nofcells : if known lines[i] : if bbwidth(lines[i])>0 : - draw lines[i] ; - fi ; fi ; endfor ; - for i=1 upto nofcells : if known texts[i] : if bbwidth(texts[i])>0 : - draw texts[i] ; - fi ; fi ; endfor ; -enddef ; - -vardef get_step_table_line (expr i) = - pair prev, self, next ; - if known texts[i] : - self := lft .5[llcorner texts[i], ulcorner texts[i] ] ; - prev := rt if known texts[i-1] : .3 else : .5 fi [lrcorner cells[i] , urcorner cells[i] ] ; - next := rt if known texts[i+1] : .7 else : .5 fi [lrcorner cells[i+1], urcorner cells[i+1]] ; - self := self shifted (-line_h_offset,0) ; - prev := prev shifted (+line_h_offset,0) ; - next := next shifted (+line_h_offset,0) ; - prev {right} ... self ... {left} next - else : - origin - fi -enddef ; - -endinput - -%D The older method let \METAPOST\ do the typesetting. The -%D macros needed for that are included here for educational -%D purposes. -%D -%D \starttypen -%D def initialize_step_variables = -%D save line_color, line_width, arrow_alternative, -%D text_fill_color, text_line_color, text_line_width, text_offset, -%D cell_fill_color, cell_line_color, cell_line_width, cell_offset, -%D line_h_offset, line_v_offset ; -%D color line_color ; line_color := .4white ; -%D numeric line_width ; line_width := 1.5pt ; -%D color text_fill_color ; text_fill_color := white ; -%D color text_line_color ; text_line_color := red ; -%D numeric text_line_width ; text_line_width := 1pt ; -%D numeric text_offset ; text_offset := 2pt ; -%D color cell_fill_color ; cell_fill_color := white ; -%D color cell_line_color ; cell_line_color := blue ; -%D numeric cell_line_width ; cell_line_width := 1pt ; -%D numeric cell_offset ; cell_offset := 2pt ; -%D numeric line_alternative ; line_alternative := 1 ; -%D numeric line_h_offset ; line_h_offset := 3pt ; -%D numeric line_v_offset ; line_v_offset := 3pt ; -%D enddef ; -%D -%D def begin_step_chart = -%D begingroup ; -%D initialize_step_variables ; -%D save steps, texts, t, b ; -%D picture cells[][] ; numeric nofcells ; nofcells := 0 ; -%D picture texts[][][] ; numeric noftexts ; noftexts := 0 ; -%D numeric t, b ; t := 1 ; b := 2 ; -%D enddef ; -%D \stoptypen -%D -%D We use a couple of macros to store the content. In the -%D second (third) alternative we will directly fill the -%D cells. -%D -%D \starttypen -%D def set_step_chart_cells (expr one, two) = -%D nofcells := nofcells + 1 ; noftexts := 0 ; -%D cells[t][nofcells] := textext.rt(one) ; -%D cells[b][nofcells] := textext.rt(two) ; -%D enddef ; -%D -%D def set_step_chart_texts (expr one, two) = -%D noftexts := noftexts + 1 ; -%D texts[t][nofcells][noftexts] := textext.rt(one) ; -%D texts[b][nofcells][noftexts] := textext.rt(two) ; -%D enddef ; -%D \stoptypen -%D -%D If you compare the building macro with the later -%D alternative, you will notice that here we explicitly -%D have to calculate the distances and positions. -%D -%D \starttypen -%D def end_step_chart = -%D numeric dx ; dx := 0 ; path p ; -%D numeric n[] ; n[t] := n[b] := 0 ; -%D numeric stepsvdistance[] ; -%D vardef bbwidth (expr p) = (xpart (lrcorner p - llcorner p)) enddef ; -%D vardef bbheight (expr p) = (ypart (urcorner p - lrcorner p)) enddef ; -%D stepsvdistance[t] := stepsvdistance[b] := 0 ; -%D for i=1 upto nofcells : -%D % find largest bbox -%D p := boundingbox steps -%D [if bbwidth(cells[t][i])>bbwidth(cells[b][i]): t else: b fi][i] ; -%D % assign largest bbox -%D for nn = t, b : -%D if bbwidth(cells[nn][i])>0 : -%D setbounds cells[nn][i] to p enlarged cell_offset ; -%D n[nn] := n[nn] + 1 ; -%D fi ; -%D endfor ; -%D % determine height -%D if n[t]>0 : -%D stepsvdistance[t] := bbheight(cells[t][1]) + intertextdistance ; -%D fi ; -%D % add to row -%D for nn = t, b : -%D cells[nn][i] := cells[nn][i] shifted (dx,stepsvdistance[nn]) ; -%D if bbwidth(cells[nn][i])>0 : -%D dowithpath (boundingbox cells[nn][i], -%D cell_line_width, cell_line_color, cell_background_color) ; -%D fi ; -%D endfor ; -%D % calculate position -%D dx := dx + interstepdistance + bbwidth(cells[b][i]) ; -%D endfor ; -%D boolean stacked ; stacked := false ; -%D numeric l[][], r[][], l[][], r[][] ; -%D pair pa, pb, pc ; path p[] ; -%D for i=1 upto nofcells : -%D l[t][i] := r[t][i] := l[b][i] := r[b][i] := 0 ; -%D endfor ; -%D % count left and right points -%D for i=1 upto nofcells : for j=1 upto nofcells : for nn = t, b : -%D if known texts[nn][i][j] : if bbwidth(texts[nn][i][j])>0 : -%D l[nn][i] := l[nn][i] + 1 ; -%D r[nn][j+i] := r[nn][j+i] + 1 ; -%D stacked := (stacked or (j>1)) ; -%D setbounds texts[nn][i][j] to boundingbox texts[nn][i][j] enlarged cell_offset ; -%D fi fi ; -%D endfor ; endfor ; endfor ; -%D % calculate left and right points -%D vardef do (expr nn, mm, ii, ss) = -%D if (l[nn][ii] > 0) and (r[nn][ii] > 0) : ss else : .5 fi -%D [ ulcorner cells[mm][ii],urcorner cells[mm][ii] ] -%D enddef ; -%D % draw arrow from left to right point -%D def dodo (expr nn, ii, jj, dd) = -%D drawarrow p[nn] -%D withpen pencircle scaled arrow_line_width -%D withcolor arrow_line_color ; -%D transform tr ; tr := identity -%D shifted point .5 along p[nn] -%D shifted -center texts[nn][ii][jj] -%D if not stacked : shifted (0,dd) fi ; -%D dowithpath ((boundingbox texts[nn][ii][jj]) transformed tr, -%D text_line_width, text_line_color, text_fill_color) ; -%D enddef ; -%D % draw top and bottom text boxes -%D for i=1 upto nofcells : for j=1 upto nofcells : -%D pickup pencircle scaled arrow_line_width ; -%D if known texts[t][i][j] : if bbwidth(texts[t][i][j]) > 0 : -%D pa := top do(t, if n[t]>0 : t else : b fi, i, .6) ; -%D pb := top do(t, if n[t]>0 : t else : b fi, j+i, .4) ; -%D pc := .5[pa,pb] shifted (0,+step_arrow_depth) ; -%D p[t] := pa {up} .. if not stacked : pc .. fi {down} pb ; -%D dodo(t, i, j, +intertextdistance) ; -%D fi fi ; -%D if known texts[b][i][j] : if bbwidth(texts[b][i][j]) > 0 : -%D pa := (bot do(b, b, i, .6)) shifted (0,-bbheight(cells[b][i])) ; -%D pb := (bot do(b, b, j+i, .4)) shifted (0,-bbheight(cells[b][j+i])) ; -%D pc := .5[pa,pb] shifted (0,-step_arrow_depth) ; -%D p[b] := pa {down} .. if not stacked : pc .. fi {up} pb ; -%D dodo(b, i, j, -intertextdistance) ; -%D fi fi ; -%D endfor ; endfor ; -%D endgroup ; -%D enddef ; -%D \stoptypen -%D -%D If you compare both methods, you will notice that the -%D first method is the cleanest, but not the most efficient -%D (since it needs \TEX\ runs within \METAPOST\ runs within -%D \TEX\ runs). diff --git a/metapost/context/mp-symb.mp b/metapost/context/mp-symb.mp deleted file mode 100644 index a84c84e82..000000000 --- a/metapost/context/mp-symb.mp +++ /dev/null @@ -1,351 +0,0 @@ -%D \module -%D [ file=mp-symb.mp, -%D version=very old, -%D title=\CONTEXT\ \METAPOST\ graphics, -%D subtitle=navigation symbol macros, -%D author=Hans Hagen, -%D date=\currentdate, -%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] -%C -%C This module is part of the \CONTEXT\ macro||package and is -%C therefore copyrighted by \PRAGMA. See mreadme.pdf for -%C details. - -%D Instead of these symbols, you can use the \type {contnav} -%D font by Taco Hoekwater that is derived form this file. - -u := 3; -h := 5u; -wt := 5u; -wb := .25wt; -o := .1u; -pw := .5u; - -drawoptions (withpen pencircle scaled pw); - -path lefttriangle, righttriangle, sublefttriangle, subrighttriangle; - -pair s ; s = (2wb,0) ; - -x1t = x2t = 0; -x3t = wt; -y3t = .5h; -z1t-z2t = (z3t-z2t) rotated 60; - -z4t = (z2t--z3t) intersectionpoint ((z1t--z2t) shifted s) ; -z5t = (z3t--z1t) intersectionpoint ((z1t--z2t) shifted s) ; - -righttriangle = z1t--z2t--z3t--cycle; -lefttriangle = righttriangle rotatedaround((0,.5h), 180) shifted (wt,0); - -subrighttriangle = z4t--((z2t--z3t--z1t) shifted s)--z5t ; -sublefttriangle = subrighttriangle rotatedaround((0,.5h), 180) shifted (wt,0); - -path sidebar; - -x1b = x4b = 0; -x2b = x3b = wb; -y1b = y2b = y1t; -y3b = y4b = y2t; - -sidebar = z1b--z2b--z3b--z4b--cycle; - -path midbar, onebar, twobar; - -hh = abs(y1t-y2t); - -%midbar := unitsquare scaled 2hh/3; -midbar := unitsquare scaled hh; -onebar := unitsquare xscaled (hh/3) yscaled hh; -twobar := onebar; - -def prepareglyph = - drawoptions (withpen pencircle scaled .5u); -enddef; - -def finishglyph = - set_outer_boundingbox currentpicture; - bboxmargin := o; - setbounds currentpicture to bbox currentpicture; -% draw boundingbox currentpicture withcolor red withpen pencircle scaled 1; -enddef; - -beginfig (1); - prepareglyph; - fill lefttriangle; - draw lefttriangle; % draw gets the bbox right, filldraw doesn't - finishglyph; -endfig; - -beginfig (2); - prepareglyph; - fill righttriangle; - draw righttriangle; - finishglyph; -endfig; - -beginfig (3); - prepareglyph; - fill sidebar; - draw sidebar; - fill lefttriangle shifted (.5s); - draw lefttriangle shifted (.5s); - finishglyph; -endfig; - -beginfig (4); - prepareglyph; - fill righttriangle; - draw righttriangle; - fill sidebar shifted (wt,0); - draw sidebar shifted (wt,0); - finishglyph; -endfig; - -beginfig (5); - prepareglyph; - fill lefttriangle; - draw lefttriangle; - fill lefttriangle shifted s; - draw lefttriangle shifted s; - finishglyph; -endfig; - -beginfig (6); - prepareglyph; - fill righttriangle; - draw righttriangle; - fill righttriangle shifted s; - draw righttriangle shifted s; - finishglyph; -endfig; - -beginfig (7); - prepareglyph; - fill midbar; - draw midbar; - finishglyph; -endfig; - -beginfig (8); - prepareglyph; - fill onebar; - draw onebar; - finishglyph; -endfig; - -beginfig (9); - prepareglyph; - fill twobar; - draw twobar; - fill twobar shifted (pw+hh/2,0); - draw twobar shifted (pw+hh/2,0); - finishglyph; -endfig; - -beginfig(101); - prepareglyph; - draw lefttriangle; - finishglyph; -endfig; - -beginfig(102); - prepareglyph; - draw righttriangle; - finishglyph; -endfig; - -beginfig(103); - prepareglyph; - draw sidebar; - draw lefttriangle shifted (.5s); - finishglyph; -endfig; - -beginfig(104); - prepareglyph; - draw righttriangle; - draw sidebar shifted (wt,0); - finishglyph; -endfig; - -beginfig(105); - prepareglyph; - draw lefttriangle; - draw lefttriangle shifted s; - finishglyph; -endfig; - -beginfig(106); - prepareglyph; - draw righttriangle; - draw righttriangle shifted s; - finishglyph; -endfig; - -beginfig(107); - prepareglyph; - draw midbar; - finishglyph; -endfig; - -beginfig(108); - prepareglyph; - draw onebar; - finishglyph; -endfig; - -beginfig(109); - prepareglyph; - draw twobar; - draw twobar shifted (pw+hh/2,0); - finishglyph; -endfig; - -beginfig(201); - prepareglyph; - draw lefttriangle; - finishglyph; -endfig; - -beginfig(202); - prepareglyph; - draw righttriangle; - finishglyph; -endfig; - -beginfig(203); - prepareglyph; - draw sidebar; - draw lefttriangle shifted (.5s); - finishglyph; -endfig; - -beginfig(204); - prepareglyph; - draw righttriangle; - draw sidebar shifted (wt,0); - finishglyph; -endfig; - -beginfig(205); - prepareglyph; - draw sublefttriangle shifted s; - draw lefttriangle shifted s; - finishglyph; -endfig; - -beginfig(206); - prepareglyph; - draw subrighttriangle; - draw righttriangle; - finishglyph; -endfig; - -beginfig(207); - prepareglyph; - draw midbar; - finishglyph; -endfig; - -beginfig(208); - prepareglyph; - draw onebar; - finishglyph; -endfig; - -beginfig(209); - prepareglyph; - draw twobar; - draw twobar shifted (pw+hh/2,0); - finishglyph; -endfig; - - -beginfig(999); - -picture collection [] ; - -prepareglyph ; -draw lefttriangle ; -finishglyph ; -collection[201] := currentpicture ; -currentpicture := nullpicture ; - -prepareglyph ; -draw righttriangle ; -finishglyph ; -collection[202] := currentpicture ; -currentpicture := nullpicture ; - -prepareglyph ; -draw sidebar ; -draw lefttriangle shifted (.5s) ; -finishglyph ; -collection[203] := currentpicture ; -currentpicture := nullpicture ; - -prepareglyph ; -draw righttriangle ; -draw sidebar shifted (wt,0) ; -finishglyph ; -collection[204] := currentpicture ; -currentpicture := nullpicture ; - -prepareglyph ; -draw sublefttriangle shifted s ; -draw lefttriangle shifted s ; -finishglyph ; -collection[205] := currentpicture ; -currentpicture := nullpicture ; - -prepareglyph ; -draw subrighttriangle ; -draw righttriangle ; -finishglyph ; -collection[206] := currentpicture ; -currentpicture := nullpicture ; - -prepareglyph ; -draw midbar ; -finishglyph ; -collection[207] := currentpicture ; -currentpicture := nullpicture ; - -prepareglyph ; -draw onebar ; -finishglyph ; -collection[208] := currentpicture ; -currentpicture := nullpicture ; - -prepareglyph ; -draw twobar ; -draw twobar shifted (pw+hh/2,0) ; -finishglyph ; -collection[209] := currentpicture ; -currentpicture := nullpicture ; - -for i=201 upto 209 : - collection[i] := collection[i] shifted - center collection[i] ; -endfor ; - -addto currentpicture also collection[205] shifted ( 0, 0) - withcolor (.3,.4,.5) ; -addto currentpicture also collection[202] shifted ( 0,1.5h) - withcolor (.5,.6,.7) ; -addto currentpicture also collection[201] shifted (1.5h, 0) - withcolor (.6,.7,.8) ; -addto currentpicture also collection[206] shifted (1.5h,1.5h) - withcolor (.4,.5,.6) ; - -collection[210] := currentpicture ; -currentpicture := nullpicture ; - -bboxmargin := .25u; - -fill bbox collection[210] withcolor .95(1,1,0); -addto currentpicture also collection[210] ; - -endfig ; - -end diff --git a/metapost/context/mp-text.mp b/metapost/context/mp-text.mp deleted file mode 100644 index cb6bb3895..000000000 --- a/metapost/context/mp-text.mp +++ /dev/null @@ -1,250 +0,0 @@ -%D \module -%D [ file=mp-text.mp, -%D version=2000.07.10, -%D title=\CONTEXT\ \METAPOST\ graphics, -%D subtitle=text support, -%D author=Hans Hagen, -%D date=\currentdate, -%D copyright={PRAGMA / Hans Hagen \& Ton Otten}] -%C -%C This module is part of the \CONTEXT\ macro||package and is -%C therefore copyrighted by \PRAGMA. See licen-en.pdf for -%C details. - -%D Under construction. - -if unknown context_tool : input mp-tool ; fi ; -if known context_text : endinput ; fi ; - -boolean context_text ; context_text := true ; - -if unknown noftexpictures : - numeric noftexpictures ; noftexpictures := 0 ; -fi ; - -if unknown texpictures[1] : - picture texpictures[] ; -fi ; - -numeric textextoffset ; textextoffset := 0 ; - -% vardef textext@#(expr txt) = -% interim labeloffset := textextoffset ; -% noftexpictures := noftexpictures + 1 ; -% if string txt : -% write "% figure " & decimal charcode & " : " & -% "texpictures[" & decimal noftexpictures & "] := btex " & -% txt & " etex ;" to jobname & ".mpt" ; -% if unknown texpictures[noftexpictures] : -% thelabel@#("unknown",origin) -% else : -% thelabel@#(texpictures[noftexpictures],origin) -% fi -% else : -% thelabel@#(txt,origin) -% fi -% enddef ; - -boolean hobbiestextext ; hobbiestextext := false ; - -vardef textext@#(expr txt) = - interim labeloffset := textextoffset ; - noftexpictures := noftexpictures + 1 ; - if string txt : - if hobbiestextext : % the tex.mp method as fallback (see tex.mp) - write "btex " & txt & " etex" to "mptextmp.mp" ; - write EOF to "mptextmp.mp" ; - scantokens "input mptextmp" - else : - write "% figure " & decimal charcode & " : " & - "texpictures[" & decimal noftexpictures & "] := btex " & - txt & " etex ;" to jobname & ".mpt" ; - if unknown texpictures[noftexpictures] : - thelabel@#("unknown",origin) - else : - thelabel@#(texpictures[noftexpictures],origin) - fi - fi - else : - thelabel@#(txt,origin) - fi -enddef ; - -string laboff_ ; laboff_ := "" ; -string laboff_c ; laboff_c := "" ; -string laboff_l ; laboff_l := ".lft" ; -string laboff_r ; laboff_r := ".rt" ; -string laboff_b ; laboff_b := ".bot" ; -string laboff_t ; laboff_t := ".top" ; -string laboff_lt ; laboff_lt := ".ulft" ; -string laboff_rt ; laboff_rt := ".urt" ; -string laboff_lb ; laboff_lb := ".llft" ; -string laboff_rb ; laboff_rb := ".lrt" ; -string laboff_tl ; laboff_tl := ".ulft" ; -string laboff_tr ; laboff_tr := ".urt" ; -string laboff_bl ; laboff_bl := ".llft" ; -string laboff_br ; laboff_br := ".lrt" ; - -vardef textextstr(expr s, a) = - save ss ; string ss ; - ss := "laboff_" & a ; - ss := scantokens ss ; - ss := "textext" & ss & "(" & ditto & s & ditto & ")" ; - scantokens ss -enddef ; - -pair laboff.origin ; laboff.origin = (infinity,infinity) ; -pair laboff.raw ; laboff.raw = (infinity,infinity) ; - -vardef thelabel@#(expr s, z) = - save p ; picture p ; - p = s if not picture s : infont defaultfont scaled defaultscale fi ; - if laboff@#<>laboff.origin : - (p shifted (z + labeloffset*laboff@# - (labxf@#*lrcorner p + - labyf@#*ulcorner p + (1-labxf@#-labyf@#)*llcorner p))) - else : - (p shifted z) - fi -enddef; - -def build_parshape (expr p, offset_or_path, dx, dy, - baselineskip, strutheight, strutdepth, topskip) = - - if unknown trace_parshape : - boolean trace_parshape ; trace_parshape := false ; - fi ; - - begingroup ; - - save q, l, r, line, tt, bb, - n, hsize, vsize, vvsize, voffset, hoffset, width, indent, - ll, lll, rr, rrr, cp, cq, t, b ; - - path q, l, r, line, tt, bb ; - numeric n, hsize, vsize, vvsize, voffset, hoffset, width[], indent[] ; - pair ll, lll, rr, rrr, cp, cq, t, b ; - - n := 0 ; cp := center p ; - - if path offset_or_path : - q := offset_or_path ; cq := center q ; - voffset := dy ; - hoffset := dx ; - else : - q := p ; cq := center q ; - hoffset := offset_or_path + dx ; - voffset := offset_or_path + dy ; - fi ; - - hsize := xpart lrcorner q - xpart llcorner q ; - vsize := ypart urcorner q - ypart lrcorner q ; - - q := p shifted - cp ; - - startsavingdata ; - - savedata "\global\parvoffset " & decimal voffset&"bp " ; - savedata "\global\parhoffset " & decimal hoffset&"bp " ; - savedata "\global\parwidth " & decimal hsize&"bp " ; - savedata "\global\parheight " & decimal vsize&"bp " ; - - if not path offset_or_path : - q := q xscaled ((hsize-2hoffset)/hsize) - yscaled ((vsize-2voffset)/vsize) ; - fi ; - - hsize := xpart lrcorner q - xpart llcorner q ; - vsize := ypart urcorner q - ypart lrcorner q ; - - t := (ulcorner q -- urcorner q) intersection_point q ; - b := (llcorner q -- lrcorner q) intersection_point q ; - - if xpart directionpoint t of q < 0 : - q := reverse q ; - fi ; - - l := q cutbefore t ; - l := l if xpart point 0 of q < 0 : & q fi cutafter b ; - - r := q cutbefore b ; - r := r if xpart point 0 of q > 0 : & q fi cutafter t ; - -% tt := (ulcorner q -- urcorner q) shifted (0,-topskip) ; -% bb := (llcorner q -- lrcorner q) shifted (0,strutdepth) ; -% -% l := l cutbefore (l intersection_point tt) ; -% l := l cutafter (l intersection_point bb) ; -% r := r cutbefore (r intersection_point bb) ; -% r := r cutafter (r intersection_point tt) ; - - if trace_parshape : - drawarrow p withpen pencircle scaled 2pt withcolor red ; - drawarrow l shifted cp withpen pencircle scaled 1pt withcolor green ; - drawarrow r shifted cp withpen pencircle scaled 1pt withcolor blue ; - fi ; - - vardef found_point (expr lin, pat, sig) = - pair a, b ; - a := pat intersection_point (lin shifted (0,strutheight)) ; - if intersection_found : - a := a shifted (0,-strutheight) ; - else : - a := pat intersection_point lin ; - fi ; - b := pat intersection_point (lin shifted (0,-strutdepth)) ; - if intersection_found : - if sig : - if xpart b > xpart a : a := b shifted (0,strutdepth) fi ; - else : - if xpart b < xpart a : a := b shifted (0,strutdepth) fi ; - fi ; - fi ; - a - enddef ; - - if (strutheight+strutdepth0) and (w>0) : scaled (w/bbwidth (p)) fi) -enddef ; - -primarydef p ysized h = - (p if (bbheight(p)>0) and (h>0) : scaled (h/bbheight(p)) fi) -enddef ; - -primarydef p xysized s = - begingroup ; - save wh, w, h ; pair wh ; numeric w, h ; - wh := paired (s) ; w := bbwidth(p) ; h := bbheight(p) ; - (p if (w>0) and (h>0) : - if xpart wh > 0 : xscaled (xpart wh/w) fi - if ypart wh > 0 : yscaled (ypart wh/h) fi - fi) - endgroup -enddef ; - -primarydef p sized wh = - (p xysized wh) -enddef ; - -def xscale_currentpicture(expr w) = - currentpicture := currentpicture xsized w ; -enddef; - -def yscale_currentpicture(expr h) = - currentpicture := currentpicture ysized h ; -enddef; - -def xyscale_currentpicture(expr w, h) = - currentpicture := currentpicture xysized (w,h) ; -enddef; - -def scale_currentpicture(expr w, h) = - currentpicture := currentpicture xsized w ; - currentpicture := currentpicture ysized h ; -enddef; - -%D A full circle is centered at the origin, while a unitsquare -%D is located in the first quadrant. Now guess what kind of -%D path fullsquare and unitcircle do return. - -path fullsquare, unitcircle ; - -fullsquare := unitsquare shifted - center unitsquare ; -unitcircle := fullcircle shifted urcorner fullcircle ; - -%D Some more paths: - -path urcircle, ulcircle, llcircle, lrcircle ; - -urcircle := origin--(+.5,0)&(+.5,0){up} ..(0,+.5)&(0,+.5)--cycle ; -ulcircle := origin--(0,+.5)&(0,+.5){left} ..(-.5,0)&(-.5,0)--cycle ; -llcircle := origin--(-.5,0)&(-.5,0){down} ..(0,-.5)&(0,-.5)--cycle ; -lrcircle := origin--(0,-.5)&(0,-.5){right}..(+.5,0)&(+.5,0)--cycle ; - -path tcircle, bcircle, lcircle, rcircle ; - -tcircle = origin--(+.5,0)&(+.5,0){up} ..(0,+.5)..{down} (-.5,0)--cycle ; -bcircle = origin--(-.5,0)&(-.5,0){down} ..(0,-.5)..{up} (+.5,0)--cycle ; -lcircle = origin--(0,+.5)&(0,+.5){left} ..(-.5,0)..{right}(0,-.5)--cycle ; -rcircle = origin--(0,-.5)&(0,-.5){right}..(+.5,0)..{left} (0,+.5)--cycle ; - -path urtriangle, ultriangle, lltriangle, lrtriangle ; - -urtriangle := origin--(+.5,0)--(0,+.5)--cycle ; -ultriangle := origin--(0,+.5)--(-.5,0)--cycle ; -lltriangle := origin--(-.5,0)--(0,-.5)--cycle ; -lrtriangle := origin--(0,-.5)--(+.5,0)--cycle ; - -path unitdiamond, fulldiamond ; - -unitdiamond := (.5,0)--(1,.5)--(.5,1)--(0,.5)--cycle ; -fulldiamond := unitdiamond shifted - center unitdiamond ; - -%D More robust: - -% let normalscaled = scaled ; -% let normalxscaled = xscaled ; -% let normalyscaled = yscaled ; -% -% def scaled expr s = normalscaled (s) enddef ; -% def xscaled expr s = normalxscaled (s) enddef ; -% def yscaled expr s = normalyscaled (s) enddef ; - -%D Shorter - -primarydef p xyscaled q = - begingroup ; save qq ; pair qq ; qq = paired(q) ; - ( p - if xpart qq<>0 : xscaled (xpart qq) fi - if ypart qq<>0 : yscaled (ypart qq) fi ) - endgroup -enddef ; - -%D Experimenteel, zie folder-3.tex. - -def set_grid(expr w, h, nx, ny) = - boolean grid[][] ; boolean grid_full ; - grid_w := w ; - grid_h := h ; - grid_nx := nx ; - grid_ny := ny ; - grid_x := round(w/grid_nx) ; % +.5) ; - grid_y := round(h/grid_ny) ; % +.5) ; - grid_left := (1+grid_x)*(1+grid_y) ; - grid_full := false ; - for i=0 upto grid_x: - for j=0 upto grid_y: - grid[i][j] := false ; - endfor ; - endfor ; -enddef ; - -vardef new_on_grid(expr _dx_, _dy_) = - dx := _dx_ ; - dy := _dy_ ; - ddx := min(round(dx/grid_nx),grid_x) ; % +.5),grid_x) ; - ddy := min(round(dy/grid_ny),grid_y) ; % +.5),grid_y) ; - if not grid_full and not grid[ddx][ddy]: - grid[ddx][ddy] := true ; - grid_left := grid_left-1 ; - grid_full := (grid_left=0) ; - true - else: - false - fi -enddef ; - -%D usage: \type{innerpath peepholed outerpath}. -%D -%D beginfig(1); -%D def fullsquare = (unitsquare shifted -center unitsquare) enddef ; -%D fill (fullsquare scaled 200) withcolor red ; -%D path p ; p := (fullcircle scaled 100) ; bboxmargin := 0 ; -%D fill p peepholed bbox p ; -%D endfig; - -secondarydef p peepholed q = - begingroup ; - save start ; pair start ; start := point 0 of p ; - if xpart start >= xpart center p : - if ypart start >= ypart center p : - urcorner q -- ulcorner q -- llcorner q -- lrcorner q -- - reverse p -- lrcorner q -- cycle - else : - lrcorner q -- urcorner q -- ulcorner q -- llcorner q -- - reverse p -- llcorner q -- cycle - fi - else : - if ypart start > ypart center p : - ulcorner q -- llcorner q -- lrcorner q -- urcorner q -- - reverse p -- urcorner q -- cycle - else : - llcorner q -- lrcorner q -- urcorner q -- ulcorner q -- - reverse p -- ulcorner q -- cycle - fi - fi - endgroup -enddef ; - -boolean intersection_found ; - -secondarydef p intersection_point q = - begingroup - save x_, y_ ; - (x_,y_) = p intersectiontimes q ; - if x_<0 : - intersection_found := false ; - center p % origin - else : - intersection_found := true ; - .5[point x_ of p, point y_ of q] - fi - endgroup -enddef ; - -%D New, undocumented, experimental: - -vardef tensecircle (expr width, height, offset) = - ((-width/2,-height/2) ... (0,-height/2-offset) ... - (+width/2,-height/2) ... (+width/2+offset,0) ... - (+width/2,+height/2) ... (0,+height/2+offset) ... - (-width/2,+height/2) ... (-width/2-offset,0) ... cycle) -enddef ; - -%vardef tensecircle (expr width, height, offset) = -% ((-width/2,-height/2)..(0,-height/2-offset)..(+width/2,-height/2) & -% (+width/2,-height/2)..(+width/2+offset,0)..(+width/2,+height/2) & -% (+width/2,+height/2)..(0,+height/2+offset)..(-width/2,+height/2) & -% (-width/2,+height/2)..(-width/2-offset,0)..(-width/2,-height/2)..cycle) -%enddef ; - -vardef roundedsquare (expr width, height, offset) = - ((offset,0)--(width-offset,0){right} .. - (width,offset)--(width,height-offset){up} .. - (width-offset,height)--(offset,height){left} .. - (0,height-offset)--(0,offset){down} .. cycle) -enddef ; - -%D Some colors. - -color cyan ; cyan = (0,1,1) ; -color magenta ; magenta = (1,0,1) ; -color yellow ; yellow = (1,1,0) ; - -%D Well, this is the dangerous and naive version: - -def drawfill text t = - fill t ; - draw t ; -enddef; - -%D This two step approach saves the path first, since it can -%D be a function. Attributes must not be randomized. - -def drawfill expr c = - path _c_ ; _c_ := c ; - do_drawfill -enddef ; - -def do_drawfill text t = - draw _c_ t ; - fill _c_ t ; -enddef; - -def undrawfill expr c = - drawfill c withcolor background -enddef ; - -%D Moved from mp-char.mp - -vardef paired (expr d) = - if pair d : d else : (d,d) fi -enddef ; - -vardef tripled (expr d) = - if color d : d else : (d,d,d) fi -enddef ; - -primarydef p enlarged d = - (p llmoved d -- p lrmoved d -- p urmoved d -- p ulmoved d -- cycle) -enddef; - -primarydef p llenlarged d = - (p llmoved d -- lrcorner p -- urcorner p -- ulcorner p -- cycle) -enddef ; - -primarydef p lrenlarged d = - (llcorner p -- p lrmoved d -- urcorner p -- ulcorner p -- cycle) -enddef ; - -primarydef p urenlarged d = - (llcorner p -- lrcorner p -- p urmoved d -- ulcorner p -- cycle) -enddef ; - -primarydef p ulenlarged d = - (llcorner p -- lrcorner p -- urcorner p -- p ulmoved d -- cycle) -enddef ; - -primarydef p llmoved d = - ((llcorner p) shifted (-xpart paired(d),-ypart paired(d))) -enddef ; - -primarydef p lrmoved d = - ((lrcorner p) shifted (+xpart paired(d),-ypart paired(d))) -enddef ; - -primarydef p urmoved d = - ((urcorner p) shifted (+xpart paired(d),+ypart paired(d))) -enddef ; - -primarydef p ulmoved d = - ((ulcorner p) shifted (-xpart paired(d),+ypart paired(d))) -enddef ; - -primarydef p leftenlarged d = - ((llcorner p) shifted (-d,0) -- lrcorner p -- - urcorner p -- (ulcorner p) shifted (-d,0) -- cycle) -enddef ; - -primarydef p rightenlarged d = - (llcorner p -- (lrcorner p) shifted (d,0) -- - (urcorner p) shifted (d,0) -- ulcorner p -- cycle) -enddef ; - -primarydef p topenlarged d = - (llcorner p -- lrcorner p -- - (urcorner p) shifted (0,d) -- (ulcorner p) shifted (0,d) -- cycle) -enddef ; - -primarydef p bottomenlarged d = - (llcorner p shifted (0,-d) -- lrcorner p shifted (0,-d) -- - urcorner p -- ulcorner p -- cycle) -enddef ; - -%D Saves typing: - -% vardef bottomboundary primary p = (llcorner p -- lrcorner p) enddef ; -% vardef rightboundary primary p = (lrcorner p -- urcorner p) enddef ; -% vardef topboundary primary p = (urcorner p -- ulcorner p) enddef ; -% vardef leftboundary primary p = (ulcorner p -- llcorner p) enddef ; - -vardef bottomboundary primary p = - if pair p : p else : (llcorner p -- lrcorner p) fi -enddef ; - -vardef rightboundary primary p = - if pair p : p else : (lrcorner p -- urcorner p) fi -enddef ; - -vardef topboundary primary p = - if pair p : p else : (urcorner p -- ulcorner p) fi -enddef ; - -vardef leftboundary primary p = - if pair p : p else : (ulcorner p -- llcorner p) fi -enddef ; - -%D Nice too: - -primarydef p superellipsed s = - superellipse - (.5[lrcorner p,urcorner p], - .5[urcorner p,ulcorner p], - .5[ulcorner p,llcorner p], - .5[llcorner p,lrcorner p], - s) -enddef ; - -primarydef p squeezed s = - ((llcorner p .. .5[llcorner p,lrcorner p] shifted ( 0, ypart paired(s)) .. lrcorner p) & - (lrcorner p .. .5[lrcorner p,urcorner p] shifted (-xpart paired(s), 0) .. urcorner p) & - (urcorner p .. .5[urcorner p,ulcorner p] shifted ( 0,-ypart paired(s)) .. ulcorner p) & - (ulcorner p .. .5[ulcorner p,llcorner p] shifted ( xpart paired(s), 0) .. llcorner p) & cycle) -enddef ; - -primarydef p randomshifted s = - begingroup ; save ss ; pair ss ; ss := paired(s) ; - p shifted (-.5xpart ss + uniformdeviate xpart ss, - -.5ypart ss + uniformdeviate ypart ss) - endgroup -enddef ; - -%primarydef p randomized s = -% for i=0 upto length(p)-1 : -% ((point i of p) randomshifted s) .. controls -% ((postcontrol i of p) randomshifted s) and -% ((precontrol (i+1) of p) randomshifted s) .. -% endfor cycle -%enddef ; - -primarydef p randomized s = - (if path p : - for i=0 upto length(p)-1 : - ((point i of p) randomshifted s) .. controls - ((postcontrol i of p) randomshifted s) and - ((precontrol (i+1) of p) randomshifted s) .. - endfor - if cycle p : - cycle - else : - ((point length(p) of p) randomshifted s) - fi - elseif pair p : - p randomshifted s - elseif color p : - if color s : - (uniformdeviate redpart s * redpart p, - uniformdeviate greenpart s * greenpart p, - uniformdeviate bluepart s * bluepart p) - elseif pair s : - ((xpart s + uniformdeviate (ypart s - xpart s)) * p) - else : - (uniformdeviate s * p) - fi - else : - p + uniformdeviate s - fi) -enddef ; - -%D Not perfect (alternative for interpath) - -vardef interpolated(expr s, p, q) = - save m ; m := max(length(p),length(q)) ; - (if path p : - for i=0 upto m-1 : - s[point (i /m) along p, - point (i /m) along q] .. controls - s[postcontrol (i /m) along p, - postcontrol (i /m) along q] and - s[precontrol ((i+1)/m) along p, - precontrol ((i+1)/m) along q] .. - endfor - if cycle p : - cycle - else : - s[point infinity of p, - point infinity of q] - fi - else : - a[p,q] - fi) -enddef ; - -%D Interesting too: - -% primarydef p parallel s = -% begingroup ; save q, b ; path q ; numeric b ; -% b := xpart (lrcorner p - llcorner p) ; -% q := p if b>0 : scaled ((b+2s)/b) fi ; -% (q shifted (center p-center q)) -% endgroup -% enddef ; - -%primarydef p parallel s = -% begingroup ; save q, w,h ; path q ; numeric w, h ; -% w := bbwidth(p) ; h := bbheight(p) ; -% q := p if (w>0) and (h>0) : -% xyscaled ((w+2*xpart paired(s))/w,(h+2*ypart paired(s))/h) fi ; -% (q shifted (center p-center q)) -% endgroup -%enddef ; - -vardef punked primary p = - (point 0 of p for i=1 upto length(p)-1 : -- point i of p endfor - if cycle p : -- cycle else : -- point length(p) of p fi) -enddef ; - -vardef curved primary p = - (point 0 of p for i=1 upto length(p)-1 : .. point i of p endfor - if cycle p : .. cycle else : .. point length(p) of p fi) -enddef ; - -primarydef p blownup s = - begingroup - save _p_ ; path _p_ ; _p_ := p xysized - (bbwidth (p)+2(xpart paired(s)), - bbheight(p)+2(ypart paired(s))) ; - (_p_ shifted (center p - center _p_)) - endgroup -enddef ; - -%D Rather fundamental. - -% vardef rightpath expr p = -% save q, t, b ; path q ; pair t, b ; -% t := (ulcorner p -- urcorner p) intersection_point p ; -% b := (llcorner p -- lrcorner p) intersection_point p ; -% if xpart directionpoint t of p < 0 : p := reverse p ; fi ; -% q := p cutbefore b ; -% q := q if xpart point 0 of p > 0 : & p fi cutafter t ; -% q -% enddef ; -% -% vardef leftpath expr p = -% save q, t, b ; path q ; pair t, b ; -% t := (ulcorner p -- urcorner p) intersection_point p ; -% b := (llcorner p -- lrcorner p) intersection_point p ; -% if xpart directionpoint t of p < 0 : p := reverse p ; fi ; -% q := p cutbefore t ; -% q := q if xpart point 0 of p > 0 : & p fi cutafter b ; -% q -% enddef ; - -def leftrightpath(expr p, l) = - save q, t, b ; path q ; pair t, b ; - t := (ulcorner p -- urcorner p) intersection_point p ; - b := (llcorner p -- lrcorner p) intersection_point p ; - if xpart directionpoint t of p < 0 : p := reverse p ; fi ; - q := p cutbefore if l: t else: b fi ; - q := q if xpart point 0 of p > 0 : & - p fi cutafter if l: b else: t fi ; - q -enddef ; - -vardef leftpath expr p = leftrightpath(p,true ) enddef ; -vardef rightpath expr p = leftrightpath(p,false) enddef ; - -%D Drawoptions - -def saveoptions = - save _op_ ; def _op_ = enddef ; -enddef ; - -%D Tracing. - -let normaldraw = draw ; -let normalfill = fill ; - -def drawlineoptions (text t) = def _lin_opt_ = t enddef ; enddef ; -def drawpointoptions (text t) = def _pnt_opt_ = t enddef ; enddef ; -def drawcontroloptions(text t) = def _ctr_opt_ = t enddef ; enddef ; -def drawlabeloptions (text t) = def _lab_opt_ = t enddef ; enddef ; -def draworiginoptions (text t) = def _ori_opt_ = t enddef ; enddef ; -def drawboundoptions (text t) = def _bnd_opt_ = t enddef ; enddef ; -def drawpathoptions (text t) = def _pth_opt_ = t enddef ; enddef ; - -def resetdrawoptions = - drawlineoptions (withpen pencircle scaled 1pt withcolor .5white) ; - drawpointoptions (withpen pencircle scaled 4pt withcolor black) ; - drawcontroloptions(withpen pencircle scaled 2.5pt withcolor black) ; - drawlabeloptions () ; - draworiginoptions (withpen pencircle scaled 1pt withcolor .5white) ; - drawboundoptions (dashed evenly _ori_opt_) ; - drawpathoptions (withpen pencircle scaled 5pt withcolor .8white) ; -enddef ; - -resetdrawoptions ; - -%D Path. - -def drawpath expr p = - normaldraw p _pth_opt_ -enddef ; - -%D Arrow. - -vardef drawarrowpath expr p = - save autoarrows ; boolean autoarrows ; autoarrows := true ; - drawarrow p _pth_opt_ -enddef ; - -%def drawarrowpath expr p = -% begingroup ; -% save autoarrows ; boolean autoarrows ; autoarrows := true ; -% save arrowpath ; path arrowpath ; arrowpath := p ; -% _drawarrowpath_ -%enddef ; -% -%def _drawarrowpath_ text t = -% drawarrow arrowpath _pth_opt_ t ; -% endgroup ; -%enddef ; - -def midarrowhead expr p = - arrowhead p cutafter - (point length(p cutafter point .5 along p)+ahlength on p) -enddef ; - -vardef arrowheadonpath (expr p, s) = - save autoarrows ; boolean autoarrows ; autoarrows := true ; - arrowhead p if s<1 : cutafter (point (s*arclength(p)+.5ahlength) on p) fi -enddef ; - -%D Points. - -def drawpoint expr c = - if string c : - string _c_ ; _c_ := "(" & c & ")" ; - dotlabel.urt(_c_, scantokens _c_) ; - drawdot scantokens _c_ - else : - dotlabel.urt("(" & decimal xpart c & "," & decimal ypart c & ")", c) ; - drawdot c - fi _pnt_opt_ -enddef ; - -%D PathPoints. - -def drawpoints expr c = path _c_ ; _c_ := c ; do_drawpoints enddef ; -def drawcontrolpoints expr c = path _c_ ; _c_ := c ; do_drawcontrolpoints enddef ; -def drawcontrollines expr c = path _c_ ; _c_ := c ; do_drawcontrollines enddef ; -def drawpointlabels expr c = path _c_ ; _c_ := c ; do_drawpointlabels enddef ; - -def do_drawpoints text t = - for _i_=0 upto length(_c_) : - normaldraw point _i_ of _c_ _pnt_opt_ t ; - endfor ; -enddef; - -def do_drawcontrolpoints text t = - for _i_=0 upto length(_c_) : - normaldraw precontrol _i_ of _c_ _ctr_opt_ t ; - normaldraw postcontrol _i_ of _c_ _ctr_opt_ t ; - endfor ; -enddef; - -def do_drawcontrollines text t = - for _i_=0 upto length(_c_) : - normaldraw point _i_ of _c_ -- precontrol _i_ of _c_ _lin_opt_ t ; - normaldraw point _i_ of _c_ -- postcontrol _i_ of _c_ _lin_opt_ t ; - endfor ; -enddef; - -boolean swappointlabels ; swappointlabels := false ; - -def do_drawpointlabels text t = - for _i_=0 upto length(_c_) : - pair _u_ ; _u_ := unitvector(direction _i_ of _c_) - rotated if swappointlabels : - fi 90 ; - pair _p_ ; _p_ := (point _i_ of _c_) ; - _u_ := 12 * defaultscale * _u_ ; - normaldraw thelabel ( decimal _i_, - _p_ shifted if cycle _c_ and (_i_=0) : - fi _u_ ) _lab_opt_ t ; - endfor ; -enddef; - -%D Bounding box. - -def drawboundingbox expr p = - normaldraw boundingbox p _bnd_opt_ -enddef ; - -%D Origin. - -numeric originlength ; originlength := .5cm ; - -def draworigin text t = - normaldraw (origin shifted (0, originlength) -- - origin shifted (0,-originlength)) _ori_opt_ t ; - normaldraw (origin shifted ( originlength,0) -- - origin shifted (-originlength,0)) _ori_opt_ t ; -enddef; - -%D Axis. - -numeric tickstep ; tickstep := 5mm ; -numeric ticklength ; ticklength := 2mm ; - -def drawxticks expr c = path _c_ ; _c_ := c ; do_drawxticks enddef ; -def drawyticks expr c = path _c_ ; _c_ := c ; do_drawyticks enddef ; -def drawticks expr c = path _c_ ; _c_ := c ; do_drawticks enddef ; - -% Adding eps prevents disappearance due to rounding errors. - -def do_drawxticks text t = - for i=0 step -tickstep until xpart llcorner _c_ - eps : - if (i<=xpart lrcorner _c_) : - normaldraw (i,-ticklength)--(i,ticklength) _ori_opt_ t ; - fi ; - endfor ; - for i=0 step tickstep until xpart lrcorner _c_ + eps : - if (i>=xpart llcorner _c_) : - normaldraw (i,-ticklength)--(i,ticklength) _ori_opt_ t ; - fi ; - endfor ; - normaldraw (llcorner _c_ -- ulcorner _c_) - shifted (-xpart llcorner _c_,0) _ori_opt_ t ; -enddef ; - -def do_drawyticks text t = - for i=0 step -tickstep until ypart llcorner _c_ - eps : - if (i<=ypart ulcorner _c_) : - normaldraw (-ticklength,i)--(ticklength,i) _ori_opt_ t ; - fi ; - endfor ; - for i=0 step tickstep until ypart ulcorner _c_ + eps : - if (i>=ypart llcorner _c_) : - normaldraw (-ticklength,i)--(ticklength,i) _ori_opt_ t ; - fi ; - endfor ; - normaldraw (llcorner _c_ -- lrcorner _c_) - shifted (0,-ypart llcorner _c_) _ori_opt_ t ; -enddef ; - -def do_drawticks text t = - drawxticks _c_ t ; - drawyticks _c_ t ; -enddef ; - -%D All of it except axis. - -def drawwholepath expr p = - draworigin ; - drawpath p ; - drawcontrollines p ; - drawcontrolpoints p ; - drawpoints p ; - drawboundingbox p ; - drawpointlabels p ; -enddef ; - -%D Tracing. - -def visualizeddraw expr c = - if picture c : normaldraw c else : path _c_ ; _c_ := c ; do_visualizeddraw fi -enddef ; - -def visualizedfill expr c = - if picture c : normalfill c else : path _c_ ; _c_ := c ; do_visualizedfill fi -enddef ; - -def do_visualizeddraw text t = - draworigin ; - drawpath _c_ t ; - drawcontrollines _c_ ; - drawcontrolpoints _c_ ; - drawpoints _c_ ; - drawboundingbox _c_ ; - drawpointlabels _c_ ; -enddef ; - -def do_visualizedfill text t = - if cycle _c_ : normalfill _c_ t fi ; - draworigin ; - drawcontrollines _c_ ; - drawcontrolpoints _c_ ; - drawpoints _c_ ; - drawboundingbox _c_ ; - drawpointlabels _c_ ; -enddef ; - -def visualizepaths = - let fill = visualizedfill ; - let draw = visualizeddraw ; -enddef ; - -def naturalizepaths = - let fill = normalfill ; - let draw = normaldraw ; -enddef ; - -extra_endfig := extra_endfig & " naturalizepaths ; " ; - -%D Normally, arrowheads don't scale well. So we provide a -%D hack. - -boolean autoarrows ; autoarrows := false ; -numeric ahfactor ; ahfactor := 2.5 ; - -def set_ahlength (text t) = - ahlength := (ahfactor*pen_size(_op_ t)) ; % _op_ added -enddef ; - -vardef pen_size (text t) = - save p ; picture p ; p := nullpicture ; - addto p doublepath (top origin -- bot origin) t ; - (ypart urcorner p - ypart lrcorner p) -enddef ; - -%D The next two macros are adapted versions of plain -%D \METAPOST\ definitions. - -def _finarr text t = - if autoarrows : set_ahlength (t) fi ; - draw _apth t ; - filldraw arrowhead _apth t ; -enddef; - -def _findarr text t = - if autoarrows : set_ahlength (t) fi ; - draw _apth t ; - fill arrowhead _apth withpen currentpen t ; - fill arrowhead reverse _apth withpen currentpen t ; -enddef ; - -%D Handy too ...... - -vardef pointarrow (expr pat, loc, len, off) = - save l, r, s, t ; path l, r ; numeric s ; pair t ; - t := if pair loc : loc else : point loc along pat fi ; -% draw t withpen pencircle scaled 10 withcolor .5white ; - s := len/2 - off ; if s<=0 : s := 0 elseif s>len : s := len fi ; - r := pat cutbefore t ; - r := (r cutafter point (arctime s of r) of r) ; - s := len/2 + off ; if s<=0 : s := 0 elseif s>len : s := len fi ; - l := reverse (pat cutafter t) ; - l := (reverse (l cutafter point (arctime s of l) of l)) ; - (l..r) -enddef ; - -def rightarrow (expr pat,tim,len) = pointarrow(pat,tim,len,-len) enddef ; -def leftarrow (expr pat,tim,len) = pointarrow(pat,tim,len,+len) enddef ; -def centerarrow (expr pat,tim,len) = pointarrow(pat,tim,len, 0) enddef ; - -%D The \type {along} and \type {on} operators can be used -%D as follows: -%D -%D \starttypen -%D drawdot point .5 along somepath ; -%D drawdot point 3cm on somepath ; -%D \stoptypen -%D -%D The number denotes a percentage (fraction). - -primarydef pct along pat = % also negative - (arctime (pct * (arclength pat)) of pat) of pat -enddef ; - -% primarydef len on pat = -% (arctime len of pat) of pat -% enddef ; - -primarydef len on pat = - (arctime if len>0 : len else : (arclength(pat)+len) fi of pat) of pat -enddef ; - -% this cuts of a piece from both ends - -% tertiarydef pat cutends len = -% begingroup ; save tap ; path tap ; -% tap := pat cutbefore (point len on pat) ; -% (tap cutafter (point -len on tap)) -% endgroup -% enddef ; - -tertiarydef pat cutends len = - begingroup ; save tap ; path tap ; - tap := pat cutbefore (point (xpart paired(len)) on pat) ; - (tap cutafter (point -(ypart paired(len)) on tap)) - endgroup -enddef ; - -%D To be documented. - -path freesquare ; - -freesquare := ((-1,0)--(-1,-1)--(0,-1)--(+1,-1)-- - (+1,0)--(+1,+1)--(0,+1)--(-1,+1)--cycle) scaled .5 ; - -numeric freelabeloffset ; freelabeloffset := 3pt ; -numeric freedotlabelsize ; freedotlabelsize := 3pt ; - -vardef thefreelabel (expr str, loc, ori) = - save s, p, q, l ; picture s ; path p, q ; pair l ; - interim labeloffset := freelabeloffset ; - s := if string str : thelabel(str,loc) else : str shifted -center str shifted loc fi ; - setbounds s to boundingbox s enlarged freelabeloffset ; - p := fullcircle scaled (2*length(loc-ori)) shifted ori ; - q := freesquare xyscaled (urcorner s - llcorner s) ; -% l := point (xpart (p intersectiontimes (ori--loc))) of q ; - l := point xpart (p intersectiontimes - (ori--((1+eps)*arclength(ori--loc)*unitvector(loc-ori)))) of q ; - setbounds s to boundingbox s enlarged -freelabeloffset ; % new - %draw boundingbox s shifted -l withpen pencircle scaled .5pt withcolor red ; - (s shifted -l) -enddef ; - -% better? - -vardef thefreelabel (expr str, loc, ori) = - save s, p, q, l ; picture s ; path p, q ; pair l ; - interim labeloffset := freelabeloffset ; - s := if string str : thelabel(str,loc) else : str shifted -center str shifted loc fi ; - setbounds s to boundingbox s enlarged freelabeloffset ; - p := fullcircle scaled (2*length(loc-ori)) shifted ori ; - q := freesquare xyscaled (urcorner s - llcorner s) ; - l := point xpart (p intersectiontimes (ori--loc shifted (loc-ori))) of q ; - setbounds s to boundingbox s enlarged -freelabeloffset ; % new - %draw boundingbox s shifted -l withpen pencircle scaled .5pt withcolor red ; - (s shifted -l) -enddef ; - -vardef freelabel (expr str, loc, ori) = - draw thefreelabel(str,loc,ori) ; -enddef ; - -vardef freedotlabel (expr str, loc, ori) = - interim linecap:=rounded ; - draw loc withpen pencircle scaled freedotlabelsize ; - draw thefreelabel(str,loc,ori) ; -enddef ; - -%D \starttypen -%D drawarrow anglebetween(line_a,line_b,somelabel) ; -%D \stoptypen - -% angleoffset ; angleoffset := 0pt ; -numeric anglelength ; anglelength := 20pt ; -numeric anglemethod ; anglemethod := 1 ; - -% vardef anglebetween (expr a, b, str) = % path path string -% save pointa, pointb, common, middle, offset ; -% pair pointa, pointb, common, middle, offset ; -% save curve ; path curve ; -% save where ; numeric where ; -% if round point 0 of a = round point 0 of b : -% common := point 0 of a ; -% else : -% common := a intersectionpoint b ; -% fi ; -% pointa := point anglelength on a ; -% pointb := point anglelength on b ; -% where := turningnumber (common--pointa--pointb--cycle) ; -% middle := ((common--pointa) rotatedaround (pointa,-where*90)) -% intersectionpoint -% ((common--pointb) rotatedaround (pointb, where*90)) ; -% if anglemethod = 0 : -% curve := pointa{unitvector(middle-pointa)}.. pointb; -% middle := point .5 along curve ; -% curve := common ; -% elseif anglemethod = 1 : -% curve := pointa{unitvector(middle-pointa)}.. pointb; -% middle := point .5 along curve ; -% elseif anglemethod = 2 : -% middle := common rotatedaround(.5[pointa,pointb],180) ; -% curve := pointa--middle--pointb ; -% elseif anglemethod = 3 : -% curve := pointa--middle--pointb ; -% elseif anglemethod = 4 : -% curve := pointa..controls middle..pointb ; -% middle := point .5 along curve ; -% fi ; -% draw thefreelabel(str, middle, common) withcolor black ; -% curve -% enddef ; - -vardef anglebetween (expr a, b, str) = % path path string - save pointa, pointb, common, middle, offset ; - pair pointa, pointb, common, middle, offset ; - save curve ; path curve ; - save where ; numeric where ; - if round point 0 of a = round point 0 of b : - common := point 0 of a ; - else : - common := a intersectionpoint b ; - fi ; - pointa := point anglelength on a ; - pointb := point anglelength on b ; - where := turningnumber (common--pointa--pointb--cycle) ; - middle := (reverse(common--pointa) rotatedaround (pointa,-where*90)) - intersection_point - (reverse(common--pointb) rotatedaround (pointb, where*90)) ; - if not intersection_found : - middle := point .5 along - ((reverse(common--pointa) rotatedaround (pointa,-where*90)) -- - ( (common--pointb) rotatedaround (pointb, where*90))) ; - fi ; - if anglemethod = 0 : - curve := pointa{unitvector(middle-pointa)}.. pointb; - middle := point .5 along curve ; - curve := common ; - elseif anglemethod = 1 : - curve := pointa{unitvector(middle-pointa)}.. pointb; - middle := point .5 along curve ; - elseif anglemethod = 2 : - middle := common rotatedaround(.5[pointa,pointb],180) ; - curve := pointa--middle--pointb ; - elseif anglemethod = 3 : - curve := pointa--middle--pointb ; - elseif anglemethod = 4 : - curve := pointa..controls middle..pointb ; - middle := point .5 along curve ; - fi ; - draw thefreelabel(str, middle, common) ; % withcolor black ; - curve -enddef ; - -% Stack - -picture currentpicturestack[] ; -numeric currentpicturedepth ; currentpicturedepth := 0 ; - -def pushcurrentpicture = - currentpicturedepth := currentpicturedepth + 1 ; - currentpicturestack[currentpicturedepth] := currentpicture ; - currentpicture := nullpicture ; -enddef ; - -def popcurrentpicture text t = % optional text - if currentpicturedepth > 0 : - addto currentpicturestack[currentpicturedepth] also currentpicture t ; - currentpicture := currentpicturestack[currentpicturedepth] ; - currentpicturedepth := currentpicturedepth - 1 ; - fi ; -enddef ; - -%D colorcircle(size, red, green, blue) ; - -% vardef colorcircle (expr size, red, green, blue) = -% save r, g, b, rr, gg, bb, cc, mm, yy ; save radius ; -% path r, g, b, rr, bb, gg, cc, mm, yy ; numeric radius ; -% -% radius := 5cm ; pickup pencircle scaled (radius/25) ; -% -% r := g := b := fullcircle scaled radius shifted (0,radius/4) ; -% -% r := r rotatedaround (origin, 15) ; -% g := g rotatedaround (origin,135) ; -% b := b rotatedaround (origin,255) ; -% -% r := r rotatedaround(center r,-90) ; -% g := g rotatedaround(center g, 90) ; -% -% gg := buildcycle(buildcycle(reverse r,b),g) ; -% cc := buildcycle(buildcycle(b,reverse g),r) ; -% -% rr := gg rotatedaround(origin,120) ; -% bb := gg rotatedaround(origin,240) ; -% -% yy := cc rotatedaround(origin,120) ; -% mm := cc rotatedaround(origin,240) ; -% -% pushcurrentpicture ; -% -% fill fullcircle scaled radius withcolor white ; -% -% fill rr withcolor red ; fill cc withcolor white-red ; -% fill gg withcolor green ; fill mm withcolor white-green ; -% fill bb withcolor blue ; fill yy withcolor white-blue ; -% -% for i = rr,gg,bb,cc,mm,yy : draw i withcolor .5white ; endfor ; -% -% currentpicture := currentpicture xsized size ; -% -% popcurrentpicture ; -% enddef ; - -% vardef colorcircle (expr size, red, green, blue) = -% save r, g, b, rr, gg, bb, cc, mm, yy ; save radius ; -% path r, g, b, rr, bb, gg, cc, mm, yy ; numeric radius ; -% -% radius := 5cm ; pickup pencircle scaled (radius/25) ; -% -% transform t ; t := identity rotatedaround(origin,120) ; -% -% r := fullcircle scaled radius -% shifted (0,radius/4) rotatedaround(origin,15) ; -% -% g := r transformed t ; b := g transformed t ; -% -% r := r rotatedaround(center r,-90) ; -% g := g rotatedaround(center g, 90) ; -% -% gg := buildcycle(buildcycle(reverse r,b),g) ; -% cc := buildcycle(buildcycle(b,reverse g),r) ; -% -% rr := gg transformed t ; bb := rr transformed t ; -% yy := cc transformed t ; mm := yy transformed t ; -% -% pushcurrentpicture ; -% -% fill fullcircle scaled radius withcolor white ; -% -% fill rr withcolor red ; fill cc withcolor white-red ; -% fill gg withcolor green ; fill mm withcolor white-green ; -% fill bb withcolor blue ; fill yy withcolor white-blue ; -% -% for i = rr,gg,bb,cc,mm,yy : draw i withcolor .5white ; endfor ; -% -% currentpicture := currentpicture xsized size ; -% -% popcurrentpicture ; -% enddef ; - -vardef colorcircle (expr size, red, green, blue) = - save r, g, b, c, m, y, w ; save radius ; - path r, g, b, c, m, y, w ; numeric radius ; - - radius := 5cm ; pickup pencircle scaled (radius/25) ; - - transform t ; t := identity rotatedaround(origin,120) ; - - r := fullcircle rotated 90 scaled radius - shifted (0,radius/4) rotatedaround(origin,135) ; - - b := r transformed t ; g := b transformed t ; - - c := buildcycle(subpath(1,7) of g,subpath(1,7) of b) ; - y := c transformed t ; m := y transformed t ; - - w := buildcycle(subpath(3,5) of r, subpath(3,5) of g,subpath(3,5) of b) ; - - pushcurrentpicture ; - - fill r withcolor red ; - fill g withcolor green ; - fill b withcolor blue ; - fill c withcolor white-red ; - fill m withcolor white-green ; - fill y withcolor white-blue ; - fill w withcolor white ; - - for i = r,g,b,c,m,y : draw i withcolor .5white ; endfor ; - - currentpicture := currentpicture xsized size ; - - popcurrentpicture ; -enddef ; - -% penpoint (i,2) of somepath -> inner / outer point - -vardef penpoint expr pnt of p = - save n, d ; numeric n, d ; - (n,d) = if pair pnt : pnt else : (pnt,1) fi ; - (point n of p shifted ((penoffset direction n of p of currentpen) scaled d)) -enddef ; - -% nice: currentpicture := inverted currentpicture ; - -primarydef p uncolored c = - image - (for i within p : - addto currentpicture - if stroked i or filled i : - if filled i : contour else : doublepath fi pathpart i - dashed dashpart i withpen penpart i - else : - also i - fi - withcolor c-(redpart i, greenpart i, bluepart i) ; - endfor ; ) -enddef ; - -vardef inverted primary p = - (p uncolored white) -enddef ; - -primarydef p softened c = - image - (save cc ; color cc ; cc := tripled(c) ; - for i within p : - addto currentpicture - if stroked i or filled i : - if filled i : contour else : doublepath fi pathpart i - dashed dashpart i withpen penpart i - else : - also i - fi - withcolor (redpart cc * redpart i, - greenpart cc * greenpart i, - bluepart cc * bluepart i) ; - endfor ;) -enddef ; - -vardef grayed primary p = - image - (for i within p : - addto currentpicture - if stroked i or filled i : - if filled i : contour else : doublepath fi pathpart i - dashed dashpart i withpen penpart i - else : - also i - fi - withcolor tripled(.30redpart i+.59greenpart i+.11bluepart i) ; - endfor ; ) -enddef ; - -% yes or no: "text" infont "cmr12" at 24pt ; - -% let normalinfont = infont ; -% -% numeric lastfontsize ; lastfontsize = fontsize defaultfont ; -% -% def infont primary name = % no vardef, no expr -% hide(lastfontsize := fontsize name) % no ; -% normalinfont name -% enddef ; -% -% def scaledat expr size = -% scaled (size/lastfontsize) -% enddef ; -% -% let at = scaledat ; - -% like decimal - -def condition primary b = if b : "true" else : "false" fi enddef ; - -% undocumented - -primarydef p stretched s = - begingroup -% save pp ; path pp ; pp := p scaled s ; - save pp ; path pp ; pp := p xyscaled s ; - (pp shifted ((point 0 of p) - (point 0 of pp))) - endgroup -enddef ; - -% yes or no, untested -) - -def xshifted expr dx = shifted(dx,0) enddef ; -def yshifted expr dy = shifted(0,dy) enddef ; - -% also handy - -% right: str = readfrom ("abc" & ".def" ) ; -% wrong: str = readfrom "abc" & ".def" ; - -% Every 62th read fails so we need to try again! - -def readfile (expr name) = - if (readfrom (name) <> EOF) : - scantokens("input " & name & " ") ; - elseif (readfrom (name) <> EOF) : - scantokens("input " & name & " ") ; - fi - closefrom (name) ; -enddef ; - -% permits redefinition of end in macro - -inner end ; - -% real fun - -let normalwithcolor = withcolor ; - -def remapcolors = - def withcolor primary c = normalwithcolor remappedcolor(c) enddef ; -enddef ; - -def normalcolors = - let withcolor = normalwithcolor ; -enddef ; - -def resetcolormap = - color color_map[][][] ; - normalcolors ; -enddef ; - -resetcolormap ; - -% color_map_resolution := 1000 ; -% -% def r_color primary c = round(color_map_resolution*redpart c) enddef ; -% def g_color primary c = round(color_map_resolution*greenpart c) enddef ; -% def b_color primary c = round(color_map_resolution*bluepart c) enddef ; - -def r_color primary c = redpart c enddef ; -def g_color primary c = greenpart c enddef ; -def b_color primary c = bluepart c enddef ; - -def remapcolor(expr old, new) = - color_map[r_color old][g_color old][b_color old] := new ; -enddef ; - -def remappedcolor(expr c) = - if known color_map[r_color c][g_color c][b_color c] : - color_map[r_color c][g_color c][b_color c] - else : - c - fi -enddef ; - -% def refill suffix c = do_repath (1) (c) enddef ; -% def redraw suffix c = do_repath (2) (c) enddef ; -% def recolor suffix c = do_repath (0) (c) enddef ; -% -% color refillbackground ; refillbackground := (1,1,1) ; -% -% def do_repath (expr mode) (suffix c) text t = % can it be stroked and filled at the same time ? -% begingroup ; -% if mode=0 : save withcolor ; remapcolors ; fi ; -% save _c_, _cc_, _f_, _b_ ; picture _c_, _cc_ ; color _f_ ; path _b_ ; -% _c_ := c ; _b_ := boundingbox c ; c := nullpicture ; -% for i within _c_ : -% _f_ := (redpart i, greenpart i, bluepart i) ; -% if bounded i : -% setbounds c to pathpart i ; -% elseif clipped i : -% clip c to pathpart i ; -% elseif stroked i : -% addto c doublepath pathpart i -% dashed dashpart i withpen penpart i -% withcolor _f_ % (redpart i, greenpart i, bluepart i) -% if mode=2 : t fi ; -% elseif filled i : -% addto c contour pathpart i -% withcolor _f_ -% if (mode=1) and (_f_<>refillbackground) : t fi ; -% else : -% addto c also i ; -% fi ; -% endfor ; -% setbounds c to _b_ ; -% endgroup ; -% enddef ; - -% Thanks to Jens-Uwe Morawski for pointing out that we need -% to treat bounded and clipped components as local pictures. - -def recolor suffix p = p := repathed (0,p) enddef ; -def refill suffix p = p := repathed (1,p) enddef ; -def redraw suffix p = p := repathed (2,p) enddef ; -def retext suffix p = p := repathed (3,p) enddef ; -def untext suffix p = p := repathed (4,p) enddef ; - -primarydef p recolored t = repathed(0,p) t enddef ; -primarydef p refilled t = repathed(1,p) t enddef ; -primarydef p redrawn t = repathed(2,p) t enddef ; -primarydef p retexted t = repathed(3,p) t enddef ; -primarydef p untexted t = repathed(4,p) t enddef ; - -color refillbackground ; refillbackground := (1,1,1) ; - -vardef repathed (expr mode, p) text t = - begingroup ; - if mode=0 : save withcolor ; remapcolors ; fi ; - save _p_, _pp_, _f_, _b_, _t_ ; - picture _p_, _pp_ ; color _f_ ; path _b_ ; transform _t_ ; - _b_ := boundingbox p ; _p_ := nullpicture ; - for i within p : - _f_ := (redpart i, greenpart i, bluepart i) ; - if bounded i : - _pp_ := repathed(mode,i) t ; - setbounds _pp_ to pathpart i ; - addto _p_ also _pp_ ; - elseif clipped i : - _pp_ := repathed(mode,i) t ; - clip _pp_ to pathpart i ; - addto _p_ also _pp_ ; - elseif stroked i : - addto _p_ doublepath pathpart i - dashed dashpart i withpen penpart i - withcolor _f_ % (redpart i, greenpart i, bluepart i) - if mode=2 : t fi ; - elseif filled i : - addto _p_ contour pathpart i - withcolor _f_ - if (mode=1) and (_f_<>refillbackground) : t fi ; - elseif textual i : % textpart i <> "" : - if mode <> 4 : - % transform _t_ ; - % (xpart _t_, xxpart _t_, xypart _t_) = (xpart i, xxpart i, xypart i) ; - % (ypart _t_, yypart _t_, yxpart _t_) = (ypart i, yypart i, yxpart i) ; - % addto _p_ also - % textpart i infont fontpart i % todo : other font - % transformed _t_ - % withpen penpart i - % withcolor _f_ - % if mode=3 : t fi ; - addto _p_ also i if mode=3 : t fi ; - fi ; - else : - addto _p_ also i ; - fi ; - endfor ; - setbounds _p_ to _b_ ; - _p_ - endgroup -enddef ; - - - - -% After a question of Denis on how to erase a z variable, Jacko -% suggested to assign whatever to x and y. So a clearz -% variable can be defined as: -% -% vardef clearz@# = -% x@# := whatever ; -% y@# := whatever ; -% enddef ; -% -% but Jacko suggested a redefinition of clearxy: -% -% def clearxy text s = -% clearxy_index_:=0; -% for $:=s: -% clearxy_index_:=clearxy_index_+1; endfor; -% if clearxy_index_=0: -% save x,y; -% else: -% forsuffixes $:=s: x$:=whatever; y$:=whatever; endfor; -% fi -% enddef; -% -% which i decided to simplify to: - -def clearxy text s = - if false for $ := s : or true endfor : - forsuffixes $ := s : x$ := whatever ; y$ := whatever ; endfor ; - else : - save x, y ; - fi -enddef ; - -% so now we can say: clearxy ; as well as clearxy 1, 2, 3 ; - -% show x0 ; z0 = (10,10) ; -% show x0 ; x0 := whatever ; y0 := whatever ; -% show x0 ; z0 = (20,20) ; -% show x0 ; clearxy 0 ; -% show x0 ; z0 = (30,30) ; - -primarydef p smoothed d = - (p llmoved (-xpart paired(d),0) -- p lrmoved (-xpart paired(d),0) {right} .. - p lrmoved (0,-ypart paired(d)) -- p urmoved (0,-ypart paired(d)) {up} .. - p urmoved (-xpart paired(d),0) -- p ulmoved (-xpart paired(d),0) {left} .. - p ulmoved (0,-ypart paired(d)) -- p llmoved (0,-ypart paired(d)) {down} .. cycle) -enddef ; - -primarydef p cornered c = - ((point 0 of p) shifted (c*(unitvector(point 1 of p - point 0 of p))) -- - for i=1 upto length(p) : - (point i-1 of p) shifted (c*(unitvector(point i of p - point i-1 of p))) -- - (point i of p) shifted (c*(unitvector(point i-1 of p - point i of p))) .. - controls point i of p .. - endfor cycle) -enddef ; - -% cmyk color support - -vardef cmyk(expr c,m,y,k) = - (1-c-k,1-m-k,1-y-k) -enddef ; - -% handy - -vardef bbwidth (expr p) = - (if known p : - if path p or picture p : - xpart (lrcorner p - llcorner p) - else : 0 fi else : 0 - fi ) -enddef ; - -vardef bbheight (expr p) = - (if known p : if path p or picture p : - ypart (urcorner p - lrcorner p) - else : 0 fi else : 0 - fi) -enddef ; - -color nocolor ; numeric noline ; % both unknown signals - -def dowithpath (expr p, lw, lc, bc) = - if known p : - if known bc : - fill p withcolor bc ; - fi ; - if known lw and known lc : - draw p withpen pencircle scaled lw withcolor lc ; - elseif known lw : - draw p withpen pencircle scaled lw ; - elseif known lc : - draw p withcolor lc ; - fi ; - fi ; -enddef ; - -% result from metafont discussion list (denisr/boguslawj) - -def ]] = ] ] enddef ; def ]]] = ] ] ] enddef ; -def [[ = [ [ enddef ; def [[[ = [ [ [ enddef ; - -% not prefect, but useful since it removes redundant points. - -vardef dostraightened(expr sign, p) = - if length(p)>2 : % was 1, but straight lines are ok - save pp ; path pp ; - pp := point 0 of p ; - for i=1 upto length(p)-1 : - if round(point i of p) <> round(point length(pp) of pp) : - pp := pp -- point i of p ; - fi ; - endfor ; - save n, ok ; numeric n ; boolean ok ; - n := length(pp) ; ok := false ; -if n>2 : - for i=0 upto n : % evt hier ook round - - if unitvector(round(point i of pp - - point if i=0 : n else : i-1 fi of pp)) <> - sign * unitvector(round(point if i=n : 0 else : i+1 fi of pp - - point i of pp)) : - if ok : -- else : ok := true ; fi point i of pp - fi - - endfor - if ok and (cycle p) : -- cycle fi -else : - pp -fi - else : - p - fi -enddef ; - -% simplified : remove same points as well as redundant points -% unspiked : remove same points as well as areas with zero distance - -% vardef simplified expr p = dostraightened(+1,p) enddef ; -% vardef unspiked expr p = dostraightened(-1,p) enddef ; - -vardef simplified expr p = - (reverse dostraightened(+1,dostraightened(+1,reverse p))) -enddef ; - -vardef unspiked expr p = - (reverse dostraightened(-1,dostraightened(-1,reverse p))) -enddef ; - -% path p ; -% p := (2cm,1cm) -- (2cm,1cm) -- (2cm,1cm) -- (3cm,1cm) -- -% (4cm,1cm) -- (4cm,2cm) -- (4cm,2.5cm) -- (4cm,3cm) -- -% (3cm,3cm) -- (2cm,3cm) -- (1cm,3cm) -- (-1cm,3cm) -- -% .5[(-1cm,3cm),(1cm,1cm)] -- (1cm,1cm) -- cycle ; -% -% p := unitcircle scaled 4cm ; -% -% drawpath p ; drawpoints p ; drawpointlabels p ; -% p := p shifted (4cm,0) ; p := straightened p ; -% drawpath p ; drawpoints p ; drawpointlabels p ; -% p := p shifted (4cm,0) ; p := straightened p ; -% drawpath p ; drawpoints p ; drawpointlabels p ; - -% new - -path originpath ; originpath := origin -- cycle ; - -vardef unitvector primary z = - if abs z = abs origin : z else : z/abs z fi -enddef; - -% also new - -vardef anchored@#(expr p, z) = - p shifted (z + (labxf@#*lrcorner p + labyf@#*ulcorner p - + (1-labxf@#-labyf@#)*llcorner p)) -enddef ; - -% epsed(1.2345) - -vardef epsed (expr e) = - e if e>0 : + eps elseif e<0 : - eps fi -enddef ; - -% handy - -def withgray primary g = - withcolor (g,g,g) -enddef ; - -% for metafun - -if unknown darkred : color darkred ; darkred := .625(1,0,0) fi ; -if unknown darkyellow : color darkyellow ; darkyellow := .625(1,1,0) fi ; -if unknown darkgray : color darkgray ; darkgray := .625(1,1,1) fi ; -if unknown lightgray : color lightgray ; lightgray := .875(1,1,1) fi ; - -% an improved plain mp macro - -vardef center primary p = - if pair p : p else : .5[llcorner p, urcorner p] fi -enddef; - -% new, yet undocumented - -vardef rangepath (expr p, d, a) = - (if length p>0 : - (d*unitvector(direction 0 of p) rotated a) - shifted point 0 of p - -- p -- - (d*unitvector(direction length(p) of p) rotated a) - shifted point length(p) of p - else : - p - fi) -enddef ; - -% under construction - -vardef straightpath(expr a, b, method) = - if (method<1) or (method>6) : - (a--b) - elseif method = 1 : - (a -- - if xpart a > xpart b : - if ypart a > ypart b : - (xpart b,ypart a) -- - elseif ypart a < ypart b : - (xpart a,ypart b) -- - fi - elseif xpart a < xpart b : - if ypart a > ypart b : - (xpart a,ypart b) -- - elseif ypart a < ypart b : - (xpart b,ypart a) -- - fi - fi - b) - elseif method = 3 : - (a -- - if xpart a > xpart b : - (xpart b,ypart a) -- - elseif xpart a < xpart b : - (xpart a,ypart b) -- - fi - b) - elseif method = 5 : - (a -- - if ypart a > ypart b : - (xpart b,ypart a) -- - elseif ypart a < ypart b : - (xpart a,ypart b) -- - fi - b) - else : - (reverse straightpath(b,a,method-1)) - fi -enddef ; - -% handy for myself - -def addbackground text t = - begingroup ; save p ; picture p ; - p := currentpicture ; currentpicture := nullpicture ; - fill boundingbox p t ; addto currentpicture also p ; - endgroup ; -enddef ; - -% makes a (line) into an infinite one (handy for calculating -% intersection points - -vardef infinite expr p = - (-infinity*unitvector(direction 0 of p) - shifted point 0 of p - -- p -- - +infinity*unitvector(direction length(p) of p) - shifted point length(p) of p) -enddef ; - -% obscure macros: create var from string and replace - and : -% (needed for process color id's) - -string _clean_ascii[] ; - -_clean_ascii[ASCII "-"] := "_" ; -_clean_ascii[ASCII ":"] := "_" ; -_clean_ascii[ASCII "."] := "_" ; - -vardef cleanstring (expr s) = - save ss ; string ss, si ; ss = "" ; - for i=0 upto length(s) : - si := substring(i,i+1) of s ; - ss := ss & if known _clean_ascii[ASCII si] : _clean_ascii[ASCII si] else : si fi ; - endfor ; - ss -enddef ; - -vardef setunstringed (expr s, v) = - scantokens(cleanstring(s)) := v ; -enddef ; - -vardef setunstringed (expr s, v) = - scantokens(cleanstring(s)) := v ; -enddef ; - -vardef getunstringed (expr s) = - scantokens(cleanstring(s)) -enddef ; - -vardef unstringed (expr s) = - expandafter known scantokens(cleanstring(s)) -enddef ; - -% new - -vardef colorpart(expr i) = - (redpart i, greenpart i,bluepart i) -enddef ; - - -% done - -endinput ; -- cgit v1.2.3