home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume8 / xfig2.8 / part12 / ruler.c < prev    next >
C/C++ Source or Header  |  1990-07-03  |  13KB  |  446 lines
  1. /* 
  2.  *    FIG : Facility for Interactive Generation of figures
  3.  *
  4.  *    Copyright (c) 1985 by Supoj Sutanthavibul (supoj@sally.UTEXAS.EDU)
  5.  *    January 1985.
  6.  *    1st revision : Aug 1985.
  7.  *
  8.  *    %W%    %G%
  9. */
  10. #include "fig.h"
  11. #include "resources.h"
  12. #include "const.h"
  13. #include "font.h"
  14. #include "paintop.h"
  15.  
  16. #define            INCH_MARK        8
  17. #define            HALF_MARK        8
  18. #define            QUARTER_MARK        6
  19. #define            SIXTEENTH_MARK        4
  20.  
  21. #define            TRM_WID            16
  22. #define            TRM_HT            8
  23. #define            SRM_WID            8
  24. #define            SRM_HT            16
  25.  
  26. extern int        CANVAS_HEIGHT, CANVAS_WIDTH;
  27. extern int        SIDERULER_WIDTH, SIDERULER_HEIGHT;
  28. extern int        TOPRULER_WIDTH, TOPRULER_HEIGHT;
  29. extern int        SIDERULER_HEIGHT, SIDERULER_START;
  30. extern int        TOPRULER_LEFT, TOPRULER_TOP;
  31. extern            null_proc();
  32. extern appresStruct    appres;
  33.  
  34. static            lasty = -100;
  35. static            lastx = -100;
  36. static int        troffx = -7, troffy = -10;
  37. static char        tr_marker_image[16] = {
  38.                 0xFE, 0xFF, /* *************** */
  39.                 0xFC, 0x7F, /*  *************  */
  40.                 0xF8, 0x3F, /*   ***********   */
  41.                 0xF0, 0x1F, /*    *********    */
  42.                 0xE0, 0x0F, /*     *******     */
  43.                 0xC0, 0x07, /*      *****      */
  44.                 0x80, 0x03, /*       ***       */
  45.                 0x00, 0x01, /*        *        */
  46.                 };
  47. static            mpr_static(trm_pr, TRM_WID, TRM_HT, 1, tr_marker_image);
  48. static int        srroffx = 2, srroffy = -7;
  49. static char        srr_marker_image[16] = {
  50.                 0x80,     /*          *  */
  51.                 0xC0,     /*         **  */
  52.                 0xE0,     /*        ***  */
  53.                 0xF0,     /*       ****  */
  54.                 0xF8,     /*      *****  */
  55.                 0xFC,     /*     ******  */
  56.                 0xFE,     /*    *******  */
  57.                 0xFF,     /*   ********  */
  58.                 0xFE,     /*    *******  */
  59.                 0xFC,     /*     ******  */
  60.                 0xF8,     /*      *****  */
  61.                 0xF0,     /*       ****  */
  62.                 0xE0,     /*        ***  */
  63.                 0xC0,     /*         **  */
  64.                 0x80,     /*          *  */
  65.                 0x00
  66.                 };
  67. static        mpr_static(srrm_pr, SRM_WID, SRM_HT, 1, srr_marker_image);
  68.  
  69. static int        srloffx = -10, srloffy = -7;
  70. static char        srl_marker_image[16] = {
  71.                 0x01,    /*  *          */
  72.                 0x03,    /*  **         */
  73.                 0x07,    /*  ***        */
  74.                 0x0F,    /*  ****       */
  75.                 0x1F,    /*  *****      */
  76.                 0x3F,    /*  ******     */
  77.                 0x7F,    /*  *******    */
  78.                 0xFF,    /*  ********   */
  79.                 0x7F,    /*  *******    */
  80.                 0x3F,    /*  ******     */
  81.                 0x1F,    /*  *****      */
  82.                 0x0F,    /*  ****       */
  83.                 0x07,    /*  ***        */
  84.                 0x03,    /*  **         */
  85.                 0x01,    /*  *          */
  86.                 0x00
  87.                 };
  88. static        mpr_static(srlm_pr, SRM_WID, SRM_HT, 1, srl_marker_image);
  89.  
  90. static Pixmap        toparrow_pm, sidearrow_pm;
  91.  
  92. set_toprulermark(x)
  93. int    x;
  94. {
  95.     XClearArea(tool_d, topruler_win,lastx + troffx,
  96.            TOPRULER_HEIGHT + troffy,trm_pr.width,
  97.            trm_pr.height, False);
  98.     XCopyArea(tool_d, toparrow_pm, topruler_win, topgc,
  99.         0, 0, trm_pr.width, trm_pr.height,
  100.         x + troffx, TOPRULER_HEIGHT + troffy);
  101.     lastx = x;
  102.     }
  103.  
  104. static Arg    ruler_args[] =
  105. {
  106.     /*  0 */ { XtNwidth, (XtArgVal) 0 },
  107.     /*  1 */ { XtNheight, (XtArgVal) 0 },
  108.     /*  2 */ { XtNlabel, (XtArgVal) "" },
  109.     /*  3 */ { XtNfromHoriz, (XtArgVal) NULL },
  110.     /*  4 */ { XtNhorizDistance, (XtArgVal) 0 },
  111.     /*  5 */ { XtNfromVert, (XtArgVal) NULL },
  112.     /*  6 */ { XtNvertDistance, (XtArgVal) 0 },
  113.     /*  7 */ { XtNresizable, (XtArgVal) False },
  114.     /*  8 */ { XtNtop, (XtArgVal) XtRubber },    /* these will be changed */
  115.     /*  9 */ { XtNbottom, (XtArgVal) XtRubber },
  116.     /* 10 */ { XtNleft, (XtArgVal) XtRubber },
  117.     /* 11 */ { XtNright, (XtArgVal) XtRubber },
  118. };
  119.  
  120. extern int    SIDERULER_WIDTH, SIDERULER_HEIGHT;
  121. extern int    TOPRULER_WIDTH, TOPRULER_HEIGHT;
  122.  
  123. int 
  124. init_sideruler(tool)
  125.     TOOL        tool;
  126. {
  127.     ruler_args[0].value = SIDERULER_WIDTH = RULER_WIDTH;
  128.     ruler_args[1].value = SIDERULER_HEIGHT = CANVAS_HEIGHT;
  129.     ruler_args[3].value = (XtArgVal) canvas_sw;    /* from right edge of canvas */
  130.     ruler_args[5].value = (XtArgVal) topruler_sw;    /* down from top ruler */
  131.     /* Place the sideruler below the topruler, next to the canvas,
  132.        but fixed offset from the top of the form */
  133.     ruler_args[8].value = (XtArgVal) XtChainTop;
  134.     ruler_args[9].value = (XtArgVal) XtRubber;
  135.     ruler_args[10].value = (XtArgVal) XtChainRight;
  136.     ruler_args[11].value = (XtArgVal) XtChainRight;
  137.     
  138.     sideruler_sw = XtCreateWidget("sruler", labelWidgetClass, tool,
  139.         ruler_args, XtNumber(ruler_args));
  140.     return(1);
  141. }
  142.  
  143. redisplay_sideruler()
  144. {
  145.     XClearWindow(tool_d, sideruler_win);
  146. }
  147.  
  148. int 
  149. init_topruler(tool)
  150.     TOOL        tool;
  151. {
  152.     ruler_args[0].value = TOPRULER_WIDTH = CANVAS_WIDTH;;    /* width */
  153.     ruler_args[1].value = TOPRULER_HEIGHT = RULER_WIDTH;    /* height */
  154.     ruler_args[3].value = (XtArgVal) panel_sw;
  155.     ruler_args[5].value = (XtArgVal) NULL;
  156.     /* fix the top & bottom to the top of the form,
  157.        the left to the panel, and the right is rubber */
  158.     ruler_args[8].value = (XtArgVal) XtChainTop;
  159.     ruler_args[9].value = (XtArgVal) XtChainTop;
  160.     ruler_args[10].value = (XtArgVal) XtChainLeft;
  161.     ruler_args[11].value = (XtArgVal) XtRubber;
  162.     
  163.     topruler_sw = XtCreateWidget("truler", labelWidgetClass, tool,
  164.         ruler_args, XtNumber(ruler_args));
  165.     return(1);
  166. }
  167.  
  168. redisplay_topruler()
  169. {
  170.     XClearWindow(tool_d, topruler_win);
  171. }
  172.  
  173. setup_rulers()
  174. {
  175.     register int        i, j;
  176.     register Pixmap        p;
  177. #define    HINCH    (PIX_PER_INCH / 2)
  178. #define    QINCH    (PIX_PER_INCH / 4)
  179. #define    SINCH    (PIX_PER_INCH / 16)
  180. #define TWOMM    (PIX_PER_CM / 5)    
  181.     char            number[3];
  182.     Arg            tmp_arg[3];
  183.     unsigned long        bg, fg;
  184.     static Arg        ruler_args[] =
  185.     {
  186.         { XtNbackgroundPixmap, (XtArgVal)NULL },
  187.     };
  188.  
  189.     topruler_win  = XtWindow(topruler_sw);
  190.     sideruler_win = XtWindow(sideruler_sw);
  191.     XDefineCursor(tool_d, topruler_win, (Cursor)bull_cursor.bitmap);
  192.     XDefineCursor(tool_d, sideruler_win, (Cursor)bull_cursor.bitmap);
  193.  
  194.     /* top ruler, adjustments for digits are kludges based on 6x13 char */
  195.     p = XCreatePixmap(tool_d, topruler_win,
  196.               TOPRULER_WIDTH, TOPRULER_HEIGHT,
  197.               DefaultDepthOfScreen(tool_s));
  198.  
  199.     XtSetArg(tmp_arg[0], XtNbackground, &bg);
  200.     XtSetArg(tmp_arg[1], XtNforeground, &fg);
  201.     XtGetValues(topruler_sw, tmp_arg, 2);
  202.  
  203.     XSetBackground(tool_d, gc, bg);
  204.     XSetForeground(tool_d, gc, bg);
  205.     XFillRectangle(tool_d, p, gc, 0, 0, TOPRULER_WIDTH,
  206.             TOPRULER_HEIGHT);
  207.     XSetForeground(tool_d, gc, fg);
  208.     
  209.     XDrawString(tool_d, p, gc, 2, TOPRULER_HEIGHT - INCH_MARK - 3,
  210.             appres.INCHES ? "in" : "cm", 2);
  211.     if(appres.INCHES) 
  212.         for (i = SINCH - 1; i <= TOPRULER_WIDTH; i += SINCH)
  213.         {
  214.         j = i + 1;
  215.         if (j % PIX_PER_INCH == 0)
  216.             {
  217.             XDrawLine(tool_d, p, gc, i, TOPRULER_HEIGHT - 1, i,
  218.                 TOPRULER_HEIGHT - INCH_MARK - 1);
  219.             sprintf(number, "%d", j / PIX_PER_INCH);
  220.             XDrawString(tool_d, p, gc, i - 3,
  221.                 TOPRULER_HEIGHT - INCH_MARK - 3, number,
  222.                 j < PIX_PER_INCH * 10 ? 1 : 2);
  223.             }
  224.         else if (j % HINCH == 0)
  225.             XDrawLine(tool_d, p, gc, i, TOPRULER_HEIGHT - 1, i,
  226.                 TOPRULER_HEIGHT - HALF_MARK - 1);
  227.         else if (j % QINCH == 0)
  228.             XDrawLine(tool_d, p, gc, i, TOPRULER_HEIGHT - 1, i,
  229.                 TOPRULER_HEIGHT - QUARTER_MARK - 1);
  230.         else if (j % SINCH == 0)
  231.             XDrawLine(tool_d, p, gc, i, TOPRULER_HEIGHT - 1, i,
  232.                 TOPRULER_HEIGHT - SIXTEENTH_MARK - 1);
  233.         }
  234.     else 
  235.         for (i = TWOMM - 1; i <= TOPRULER_WIDTH; i++)
  236.         {
  237.         j = i + 1;
  238.         if (j % PIX_PER_CM == 0)
  239.             {
  240.             XDrawLine(tool_d, p, gc, i, TOPRULER_HEIGHT - 1, i,
  241.                   TOPRULER_HEIGHT - INCH_MARK - 1);
  242.             sprintf(number, "%d", j / PIX_PER_CM);
  243.             XDrawString(tool_d, p, gc, i - 3,
  244.                     TOPRULER_HEIGHT - INCH_MARK - 3, number,
  245.                     j < PIX_PER_CM * 10 ? 1 : 2);
  246.             }
  247.         else if (j % TWOMM == 0)
  248.             XDrawLine(tool_d, p, gc, i, TOPRULER_HEIGHT - 1, i,
  249.                   TOPRULER_HEIGHT - QUARTER_MARK - 1);
  250.         }
  251.     ruler_args[0].value = (XtArgVal) p;
  252.     XtSetValues(topruler_sw, ruler_args, 1);
  253.  
  254.     /* The arrows will be XORed into the rulers.
  255.        We want the foreground color in the arrow to result in
  256.        the foreground or background color in the display.
  257.        so if the source pixel is fg^bg, it produces fg when XOR'ed
  258.        with bg, and bg when XOR'ed with bg.
  259.  
  260.        If the source pixel is zero, it produces fg when XOR'ed with
  261.        fg, and bg when XOR'ed with bg.
  262.        */
  263.     XSetForeground(tool_d, gc, fg ^ bg);
  264.     XSetBackground(tool_d, gc, 0);
  265.  
  266.     /* make pixmaps for top ruler arrow */
  267.     toparrow_pm = XCreatePixmap(tool_d, topruler_win, trm_pr.width,
  268.                     trm_pr.height,
  269.                     DefaultDepthOfScreen(tool_s));
  270.     XPutImage(tool_d, toparrow_pm, gc, &trm_pr, 0, 0, 0, 0,
  271.         trm_pr.width, trm_pr.height);
  272.     
  273.     /* side ruler, adjustments for digits are kludges based on 6x13 char */
  274.     p = XCreatePixmap(tool_d, sideruler_win,
  275.               SIDERULER_WIDTH, SIDERULER_HEIGHT,
  276.               DefaultDepthOfScreen(tool_s));
  277.     XtSetArg(tmp_arg[0], XtNbackground, &bg);
  278.     XtSetArg(tmp_arg[1], XtNforeground, &fg);
  279.     XtGetValues(sideruler_sw, tmp_arg, 2);
  280.  
  281.     XSetBackground(tool_d, gc, bg);
  282.     XSetForeground(tool_d, gc, bg);
  283.     XFillRectangle(tool_d, p, gc, 0, 0, SIDERULER_WIDTH,
  284.             SIDERULER_HEIGHT);
  285.     XSetForeground(tool_d, gc, fg);
  286.     
  287.     if( appres.INCHES ) 
  288.     {
  289.         if( appres.RHS_PANEL )
  290.         {
  291.         for (i = SINCH - 1; i <= SIDERULER_HEIGHT; i += SINCH)
  292.         {
  293.             j = i + 1;
  294.             if (j % PIX_PER_INCH == 0)
  295.             {
  296.                 XDrawLine(tool_d, p, gc, RULER_WIDTH-INCH_MARK,
  297.                       i, RULER_WIDTH, i);
  298.                 sprintf(number, "%d", j / PIX_PER_INCH);
  299.                 XDrawString(tool_d, p, gc,
  300.                         RULER_WIDTH-INCH_MARK - 8, i + 3,
  301.                         number, j < PIX_PER_INCH * 10 ? 1 : 2);
  302.             }
  303.             else if (j % QINCH == 0)
  304.                 XDrawLine(tool_d, p, gc,
  305.                       RULER_WIDTH-QUARTER_MARK, i,
  306.                       RULER_WIDTH, i);
  307.             else if (j % SINCH == 0)
  308.                 XDrawLine(tool_d, p, gc,
  309.                       RULER_WIDTH-SIXTEENTH_MARK, i,
  310.                       RULER_WIDTH, i);
  311.         }
  312.         }
  313.         else
  314.         {
  315.         for (i = SINCH - 1; i <= SIDERULER_HEIGHT; i += SINCH)
  316.         {
  317.             j = i + 1;
  318.             if (j % PIX_PER_INCH == 0)
  319.             {
  320.                 XDrawLine(tool_d, p, gc, 0, i,
  321.                       INCH_MARK - 1, i);
  322.                 sprintf(number, "%d", j / PIX_PER_INCH);
  323.                 XDrawString(tool_d, p, gc, INCH_MARK + 3,
  324.                         i + 3, number,
  325.                         j < PIX_PER_INCH * 10 ? 1 : 2);
  326.             }    
  327.             else if (j % QINCH == 0)
  328.                 XDrawLine(tool_d, p, gc, 0, i,
  329.                       QUARTER_MARK - 1, i);
  330.             else if (j % SINCH == 0)
  331.                 XDrawLine(tool_d, p, gc, 0, i,
  332.                       SIXTEENTH_MARK - 1, i);
  333.         }    
  334.         }
  335.     }
  336.     else 
  337.     {
  338.         if( appres.RHS_PANEL )
  339.         {
  340.         for (i = TWOMM - 1; i <= SIDERULER_HEIGHT; i++)
  341.         {
  342.             j = i + 1;
  343.             if (j % PIX_PER_CM == 0)
  344.             {
  345.                 XDrawLine(tool_d, p, gc, RULER_WIDTH-INCH_MARK,
  346.                       i, RULER_WIDTH, i);
  347.                 sprintf(number, "%d", j / PIX_PER_CM);
  348.                 XDrawString(tool_d, p, gc,
  349.                         RULER_WIDTH-INCH_MARK - 8, i + 3,
  350.                         number, j < PIX_PER_CM * 10 ? 1 : 2);
  351.             }
  352.             else if (j % TWOMM == 0)
  353.                 XDrawLine(tool_d, p, gc,
  354.                       RULER_WIDTH-QUARTER_MARK, i,
  355.                       RULER_WIDTH, i);
  356.         }
  357.         }
  358.         else
  359.         {
  360.         for (i = TWOMM - 1; i <= SIDERULER_HEIGHT; i++)
  361.         {
  362.             j = i + 1;
  363.             if (j % PIX_PER_CM == 0)
  364.             {
  365.                 XDrawLine(tool_d, p, gc, 0, i,
  366.                       INCH_MARK - 1, i);
  367.                 sprintf(number, "%d", j / PIX_PER_CM);
  368.                 XDrawString(tool_d, p, gc, INCH_MARK + 3,
  369.                         i + 3, number,
  370.                         j < PIX_PER_CM * 10 ? 1 : 2);
  371.             }
  372.             else if (j % TWOMM == 0)
  373.                 XDrawLine(tool_d, p, gc, 0, i,
  374.                       QUARTER_MARK - 1, i);
  375.                 }
  376.         }
  377.     }
  378.     ruler_args[0].value = (XtArgVal) p;
  379.     XtSetValues(sideruler_sw, ruler_args, 1);
  380.  
  381.     /* Colors set as above */
  382.     XSetForeground(tool_d, gc, fg ^ bg);
  383.     XSetBackground(tool_d, gc, 0);
  384.  
  385.     /* make pixmaps for side ruler arrow */
  386.     if( appres.RHS_PANEL )
  387.     {
  388.         sidearrow_pm = XCreatePixmap(tool_d, sideruler_win,
  389.                          srlm_pr.width, srlm_pr.height,
  390.                          DefaultDepthOfScreen(tool_s));
  391.         XPutImage(tool_d, sidearrow_pm, gc, &srlm_pr, 0, 0, 0, 0,
  392.               srlm_pr.width, srlm_pr.height);
  393.     }
  394.     else
  395.     {
  396.         sidearrow_pm = XCreatePixmap(tool_d, sideruler_win,
  397.                          srrm_pr.width, srrm_pr.height,
  398.                          DefaultDepthOfScreen(tool_s));
  399.         XPutImage(tool_d, sidearrow_pm, gc, &srrm_pr, 0, 0, 0, 0,
  400.               srrm_pr.width, srrm_pr.height);
  401.     }
  402. }
  403.  
  404. set_rulermark(x, y)
  405. int    x, y;
  406. {
  407.     if( appres.TRACKING )
  408.     {
  409.         set_siderulermark(y);
  410.         set_toprulermark(x);
  411.     }
  412. }
  413.  
  414. redisplay_rulers()
  415. {
  416.     redisplay_topruler();
  417.     redisplay_sideruler();
  418. }
  419.  
  420. set_siderulermark(y)
  421. int    y;
  422. {
  423.     if( appres.RHS_PANEL ) {
  424.         /* Because the ruler uses a background pixmap, we can win
  425.            here by using XClearArea to erase the old thing. */
  426.         XClearArea(tool_d, sideruler_win,
  427.                RULER_WIDTH+srloffx, lasty + srloffy,
  428.                srlm_pr.width, srlm_pr.height, False);
  429.         XCopyArea(tool_d, sidearrow_pm, sideruler_win,
  430.               sidegc, 0, 0, srlm_pr.width,
  431.               srlm_pr.height, RULER_WIDTH+srloffx, y + srloffy);
  432.     }
  433.     else
  434.     {
  435.         /* Because the ruler uses a background pixmap, we can win
  436.            here by using XClearArea to erase the old thing. */
  437.         XClearArea(tool_d, sideruler_win,
  438.                srroffx, lasty + srroffy,
  439.                srlm_pr.width, srlm_pr.height, False);
  440.         XCopyArea(tool_d, sidearrow_pm, sideruler_win,
  441.               sidegc, 0, 0, srrm_pr.width,
  442.               srrm_pr.height, srroffx, y + srroffy);
  443.     }
  444.     lasty = y;
  445. }
  446.