Return to draw.c CVS log

Up to [CSRG BSD Unix] / 41BSD / cmd / cifplot

Annotation of 41BSD/cmd/cifplot/draw.c, revision 1.1.1.1

1.1       root        1: /*******************************************************************
                      2: *                                                                  *
                      3: *    File: CIFPLOT/draw.c                                          *
                      4: *    Written by Dan Fitzpatrick                                    *
                      5: *    copyright 1980 -- Regents of the University of California     *
                      6: *                                                                  *
                      7: ********************************************************************/
                      8: 
                      9: #include <stdio.h>
                     10: #include "defs.h"
                     11: #include "globals.h"
                     12: #include "parser_defs.h"
                     13: #include "structs.h"
                     14: #include "out_structs.h"
                     15: 
                     16: IMPORT nedge *AllocHolder();
                     17: IMPORT PutQueue();
                     18: IMPORT GetQueue();
                     19: IMPORT AddLine();
                     20: IMPORT Fill();
                     21: 
                     22: SendDisplay(a,da,b,db,l)
                     23: register int l;
                     24: real a,b,da,db;
                     25: /* SendDisplay sends the y positions a & b to be displayed on plot
                     26:  * Each raster line the value of a & b change by da & db */
                     27: {
                     28:     if(a > b) Error("Edge is backwards in SendEdge",INTERNAL);
                     29:     if(a < 0) Error("bad value in SendEdge",INTERNAL);
                     30:     if(a == b && da == db && l != 0) return;  /* Ignore 0 width lines */
                     31:     if(EdgeHolder[l] != NIL)
                     32:        if(a<EdgeHolder[l]->end || (a==EdgeHolder[l]->end &&  da <= EdgeHolder[l]->dend)) {
                     33:            /* If this run overlaps the last run combine them 
                     34:             * and return
                     35:             * if not send out last run and create new run
                     36:             * if equal do not combine since dy may diverge */
                     37:            EdgeHolder[l]->end = b;
                     38:            EdgeHolder[l]->dend = db;
                     39:            return;
                     40:            }
                     41:          else
                     42:             PutQueue(EdgeHolder[l],&(NEdgeQueue[l]));
                     43:     EdgeHolder[l] = AllocHolder();
                     44:     EdgeHolder[l]->start = a;
                     45:     EdgeHolder[l]->end = b;
                     46:     EdgeHolder[l]->dstart = da;
                     47:     EdgeHolder[l]->dend = db;
                     48:     }
                     49: 
                     50: FinnishLine(l,xcurrent)
                     51: int l;
                     52: /* Causes last holder to be put on queue, calls AddLine */
                     53: {
                     54:     if(EdgeHolder[l] != NIL)
                     55:        PutQueue(EdgeHolder[l],&(NEdgeQueue[l]));
                     56:     EdgeHolder[l] = NIL;
                     57:     AddLine(l,xcurrent);
                     58:     }
                     59: 
                     60: /*
                     61: Draw(i,xcurrent)
                     62: register int i,xcurrent;
                     63: {
                     64:     register nedge *e;
                     65: 
                     66:     return;
                     67:     /* Fill between edges; compute outlines if outline is true
                     68:      * and the pattern is not black. (If the pattern is black
                     69:      * outlines do not appear anyway.) */
                     70:     /*
                     71:     if(outline && Pats[i][ModCount] != 0xFFFFFFFF)
                     72:        for(e=(nedge *) NecEdgeQueue[i].QStart; e!=NIL; e=e->Link) {
                     73:            if(e->dstart > 0.0)
                     74:                Fill(xcurrent,(int) e->start,(int) (e->start + e->dstart),0xFFFFFFFF);
                     75:              else
                     76:                Fill(xcurrent,(int) (e->start + e->dstart),(int) e->start,0xFFFFFFFF);
                     77:            if(e->dend > 0.0)
                     78:                Fill(xcurrent,(int) e->end+1,(int) (e->end + e->dend)+1,0xFFFFFFFF);
                     79:              else
                     80:                Fill(xcurrent,(int) (e->end + e->dend)+1,(int) e->end+1,0xFFFFFFFF);
                     81:            e->start += e->dstart; e->end += e->dend;
                     82:            Fill(xcurrent,(int) e->start, (int) e->end,Pats[i][ModCount]);
                     83:            }
                     84:       else
                     85:        for(e=(nedge *) NecEdgeQueue[i].QStart; e!=NIL; e=e->Link)
                     86:            Fill(xcurrent,(int) (e->start+= e->dstart), (int) (e->end+= e->dend)+1,Pats[i][ModCount]);
                     87:     }
                     88:     */
                     89: 
                     90: 
                     91: OutputTrap(layer,xcurrent)
                     92: int layer,xcurrent;
                     93: {
                     94:     register nedge *e;
                     95:     register real diff;
                     96:     if(extractor) {
                     97:        ExtractorOutput(xcurrent);
                     98:        return;
                     99:        }
                    100:     diff = xcurrent - xprev[layer] - 1;
                    101:     for(e=(nedge *) NecEdgeQueue[layer].QStart; e!=NIL; e=e->Link) {
                    102:        FillTrap(e->start,e->end,e->dstart,e->dend,xprev[layer],xcurrent,layer);
                    103:        e->start += e->dstart * diff;   e->end += e->dend * diff;
                    104:        }
                    105:     xprev[layer] = xcurrent;
                    106:     }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.