home *** CD-ROM | disk | FTP | other *** search
/ Spanish Scene 4 / SpanishScene4.iso / Programas / DavidBarbion_Ind / backclock_V232c.lha / BackClock / sources / tracewin.c < prev    next >
C/C++ Source or Header  |  1999-06-11  |  10KB  |  277 lines
  1. /*****************************************************************************
  2.  *
  3.  * Nom:                         tracewin.c
  4.  * Desc:                        fonctions de traçage dans les fenetres
  5.  *
  6.  *
  7.  * version                      : $VER: tracewin.c 2.5 (05.06.99)
  8.  *
  9.  * lastchange                   : 11.06.99
  10.  *
  11.  * ver2.3: fill background or transparent
  12.  * ver2.3ß3: CyberGraphics support (beta)
  13.  * ver2.3ß4: BugFixed but beta CGX
  14.  * ver2.3ß5: Filled needles(option), no direct CGX support (deleted)
  15.  * ver2.4  : added shadow and middle point drawings
  16.  * ver2.5  : uses rtracker.library
  17.  *         + opens in front of wb and do
  18.  *
  19.  *****************************************************************************
  20.  */ 
  21. #include <exec/memory.h>
  22. #include <graphics/rastport.h>
  23. #include <proto/graphics.h>
  24. #include <proto/exec.h>
  25. #include <math.h>
  26. #include "utils.h"
  27. #include "tracewin.h"
  28. #include "partial.h"
  29. #include <graphics/gfxmacros.h>
  30. #include <exec/libraries.h>
  31. #include <clib/rtracker_protos.h>
  32. #include <pragmas/rtracker_pragmas.h>
  33.  
  34. extern struct Library * RTrackerLibrary ;
  35. /*UWORD area_pat[] = {
  36.   0xf0f0,0xf0f0,0xf0f0, 0xf0f0, 0x0f0f, 0x0f0f, 0x0f0f, 0x0f0f
  37. } ;*/
  38.  
  39. PLANEPTR tmpbitmap ;
  40. USHORT Xplane, Yplane ;
  41.  
  42. struct pt ptSec,
  43.           ptMin,
  44.           ptHeu ;
  45. ULONG mX, mY ;
  46.  
  47. void initwin(idWin * prj) {
  48.   int i ;
  49.   
  50.   mX = prj->backWin.width / 2 ;
  51.   mY = prj->backWin.height / 2 ;
  52.   if (prj->RP1) {
  53.     if(prj->backWin.fill) {
  54.       SetAPen(prj->RP1, prj->backWin.cmap[COL_BAC].reg) ;
  55.       RectFill(prj->RP1, 0, 0, prj->backWin.width-1, prj->backWin.height-1) ;
  56.     }
  57.     SetAPen(prj->RP1, prj->backWin.cmap[COL_TIC].reg) ;                                                       // couleur jaune
  58.     for(i = 0; i < 360; i+=30) {
  59.       /* trace les repères des heures
  60.       */
  61.       Move(prj->RP1, ULONG(cos(PI*i/180.0) * (mX-mX/10L)) + mX, ULONG(sin(PI*i/180.0) * (mY-mY/10L)) + mY) ;
  62.       Draw(prj->RP1, ULONG(cos(PI*i/180.0) * mX) + mX, ULONG(sin(PI*i/180.0) * mY) + mY) ;
  63.     }
  64.     
  65.   }
  66.   /* initalisation des points des aiguilles
  67.    */
  68.   /* secondes
  69.    */
  70.   ptSec.points = 2 ;
  71.   ptSec.fill   = FALSE ;
  72.   ptSec.pt_buffer = NULL ; // idem
  73.   ptSec.A[0]   = 0 ;
  74.   ptSec.A[1]   = 180 ;
  75.   ptSec.M[0]   = 5.0 ;
  76.   ptSec.M[1]   = 1.2 ;
  77.   ptSec.angle  = ANGLE_S ;
  78.   /* heures
  79.    */
  80.   ptHeu.points = 5 ;
  81.   ptHeu.fill   = TRUE ;
  82.   ptHeu.pt_buffer = NewAllocMem(10 * ptHeu.points, MEMF_PUBLIC) ;
  83.   ptHeu.A[0]   = 0 ;
  84.   ptHeu.A[1]   = 100 ;
  85.   ptHeu.A[2]   = 180 ;
  86.   ptHeu.A[3]   = -100 ;
  87.   ptHeu.A[4]   = 0 ;
  88.   ptHeu.M[0]   = 3.0 ;
  89.   ptHeu.M[1]   = 1.1 ;
  90.   ptHeu.M[2]   = 1.2 ;
  91.   ptHeu.M[3]   = 1.1 ;
  92.   ptHeu.M[4]   = 3.0 ;
  93.   ptHeu.angle  = ANGLE_H ;
  94.   
  95.   /* minutes
  96.    */
  97.   ptMin.points =   5 ;
  98.   ptMin.fill   = TRUE ;
  99.   ptMin.pt_buffer = NewAllocMem(10 * ptMin.points, MEMF_PUBLIC) ;
  100.   ptMin.A[0]   =   0 ;
  101.   ptMin.A[1]   =  150 ;
  102.   ptMin.A[2]   = 180 ;
  103.   ptMin.A[3]   = -150 ;
  104.   ptMin.A[4]   =   0 ;
  105.   ptMin.M[0]   =   4 ;
  106.   ptMin.M[1]   =   1.3 ;
  107.   ptMin.M[2]   =   1.2 ;
  108.   ptMin.M[3]   =   1.3 ;
  109.   ptMin.M[4]   =   4 ;
  110.   ptMin.angle  = ANGLE_M ;
  111.   
  112.   prj->ai     = NewAllocMem(sizeof(struct AreaInfo), MEMF_PUBLIC|MEMF_CLEAR) ;
  113.  
  114.   //SetAfPt(prj->RP2, area_pat, 3) ;
  115.   effacer(prj) ;
  116.   retracer(prj) ;
  117.  
  118. }
  119. void free_twin(idWin * prj) {
  120.   /* free vertice buffer
  121.    * areainfo and tmpras buffer
  122.    */
  123.   if (ptSec.pt_buffer) NewFreeVec(ptSec.pt_buffer) ;
  124.   if (ptMin.pt_buffer) NewFreeVec(ptMin.pt_buffer) ;
  125.   if (ptHeu.pt_buffer) NewFreeVec(ptHeu.pt_buffer) ;
  126.   if (prj->ai)         NewFreeVec(prj->ai) ;
  127. }
  128.  
  129. void reinit_win(idWin * prj) {
  130.   free_twin(prj) ;
  131.   initwin(prj) ;
  132. }
  133.  
  134. void effacer(idWin * prj) {
  135. //  BltBitMapRastPort(prj->wb->RastPort.BitMap, prj->backWin.posX, prj->backWin.posY, prj->RP1, 0, 0, prj->backWin.width, prj->backWin.height, 0xc0) ;
  136.   WaitBlit() ;
  137.   BltBitMapRastPort(prj->RP1->BitMap, 0,0, prj->RP2, 0, 0, prj->backWin.width, prj->backWin.height, 0xc0) ;
  138. }
  139. void retracer(idWin * prj) {
  140.   UWORD patt[]={0x5555,0xaaaa} ;
  141.   if (prj->backWin.drawsha) {
  142.     //drawShadow()
  143.     prj->RP2->AreaPtrn = patt ;
  144.     prj->RP2->AreaPtSz = 1 ; 
  145.     SetDrMd(prj->RP2, JAM1) ;
  146.     SetAPen(prj->RP2, prj->backWin.cmap[COL_BLA].reg) ;
  147.     tracerOmbre(prj, &ptHeu, prj->heu, prj->min/2) ;
  148.     tracerOmbre(prj, &ptMin, prj->min, NULL) ;
  149.     if (prj->backWin.drawsec) {
  150.       prj->RP2->LinePtrn = 0xaaaa ;
  151.       tracerOmbre(prj, &ptSec, prj->sec, NULL) ;
  152.       prj->RP2->LinePtrn = 0xffff ;
  153.     }
  154.     prj->RP2->AreaPtrn = NULL ; 
  155.   }
  156.   SetAPen(prj->RP2, prj->backWin.cmap[COL_HEU].reg) ;
  157.   tracerAiguilles(prj, &ptHeu, prj->heu, prj->min/2) ;
  158.   SetAPen(prj->RP2, prj->backWin.cmap[COL_MIN].reg) ;
  159.   tracerAiguilles(prj, &ptMin, prj->min, NULL) ;
  160.   if (prj->backWin.drawsec) {
  161.     SetAPen(prj->RP2, prj->backWin.cmap[COL_SEC].reg) ;
  162.     tracerAiguilles(prj, &ptSec, prj->sec, NULL) ;
  163.   }
  164.   if(prj->backWin.drawmpo) {
  165.     SetAPen(prj->RP2, prj->backWin.cmap[COL_MPO].reg) ;
  166.     WritePixel(prj->RP2, mX, mY) ;
  167.     WritePixel(prj->RP2, mX-1, mY) ;
  168.     WritePixel(prj->RP2, mX, mY-1) ;
  169.     WritePixel(prj->RP2, mX-1, mY-1) ;
  170.     WritePixel(prj->RP2, mX+1, mY) ;
  171.     WritePixel(prj->RP2, mX, mY+1) ;
  172.     WritePixel(prj->RP2, mX+1, mY+1) ;
  173.     
  174.     
  175.     
  176.   }
  177.  
  178.   WaitBlit() ;
  179.   BltBitMapRastPort(prj->RP2->BitMap, 0,0, prj->win->RPort, 0, 0, prj->backWin.width, prj->backWin.height, 0xc0) ;
  180.   GoAhead(prj) ;
  181. }
  182. void tracerAiguilles(idWin * prj, struct pt * ptAigu, UBYTE p_time, UBYTE an_inc) {
  183.   /*
  184.    * Trace une aiguille
  185.    */
  186.   int i ;
  187.   
  188.   Move(prj->RP2, mX+(ULONG)(cos(PI*(ptAigu->A[0]+p_time*ptAigu->angle+an_inc-90.0)/180.0)*(mX-mX/ptAigu->M[0])), 
  189.                         mY+(ULONG)(sin(PI*(ptAigu->A[0]+p_time*ptAigu->angle+an_inc-90.0)/180.0)*(mY-mY/ptAigu->M[0]))) ;
  190.  
  191.   if (!ptAigu->fill || (prj->backWin.filln == 0)) {
  192.     // tracer sans remplissage
  193.     // no fill
  194.     for(i = 0; i<ptAigu->points; i++)
  195.       Draw(prj->RP2, mX+(ULONG)(cos(PI*(ptAigu->A[i]+p_time*ptAigu->angle+an_inc-90.0)/180.0)*(mX-mX/ptAigu->M[i])), 
  196.                             mY+(ULONG)(sin(PI*(ptAigu->A[i]+p_time*ptAigu->angle+an_inc-90.0)/180.0)*(mY-mY/ptAigu->M[i]))) ;
  197.   }else {
  198.     // avec remplissage
  199.     // fill
  200.     prj->RP2->AreaInfo = prj->ai ;
  201.     InitArea(prj->ai, ptAigu->pt_buffer, ptAigu->points+2) ;
  202.     
  203.     AreaMove(prj->RP2, (SHORT)mX+(ULONG)(cos(PI*(ptAigu->A[0]+p_time*ptAigu->angle+an_inc-90.0)/180.0)*(mX-mX/ptAigu->M[0])), 
  204.                               (SHORT)mY+(ULONG)(sin(PI*(ptAigu->A[0]+p_time*ptAigu->angle+an_inc-90.0)/180.0)*(mY-mY/ptAigu->M[0]))) ;
  205.  
  206.     for(i = 0; i < ptAigu->points; i++) 
  207.       AreaDraw(prj->RP2, (SHORT)mX+(ULONG)(cos(PI*(ptAigu->A[i]+p_time*ptAigu->angle+an_inc-90.0)/180.0)*(mX-mX/ptAigu->M[i])), 
  208.                                 (SHORT)mY+(ULONG)(sin(PI*(ptAigu->A[i]+p_time*ptAigu->angle+an_inc-90.0)/180.0)*(mY-mY/ptAigu->M[i]))) ;
  209.       
  210.     AreaEnd(prj->RP2) ;
  211.   }
  212. }
  213. void tracerOmbre(idWin * prj, struct pt * ptAigu, UBYTE p_time, UBYTE an_inc) {
  214.   /* trace l'ombre de l'aiguille
  215.    */
  216.   int i ;
  217.   LONG offset ;
  218.   
  219.   offset = (5 * ((mX*2 + mY*2) / 2.0))/135.0 ;
  220.   
  221.   Move(prj->RP2, offset+mX+(ULONG)(cos(PI*(ptAigu->A[0]+p_time*ptAigu->angle+an_inc-90.0)/180.0)*(mX-mX/ptAigu->M[0])), 
  222.                         offset+mY+(ULONG)(sin(PI*(ptAigu->A[0]+p_time*ptAigu->angle+an_inc-90.0)/180.0)*(mY-mY/ptAigu->M[0]))) ;
  223.  
  224.   if (!ptAigu->fill || (prj->backWin.filln == 0)) {
  225.     // tracer sans remplissage
  226.     // no fill
  227.     for(i = 0; i<ptAigu->points; i++)
  228.       Draw(prj->RP2, offset+mX+(ULONG)(cos(PI*(ptAigu->A[i]+p_time*ptAigu->angle+an_inc-90.0)/180.0)*(mX-mX/ptAigu->M[i])), 
  229.                             offset+mY+(ULONG)(sin(PI*(ptAigu->A[i]+p_time*ptAigu->angle+an_inc-90.0)/180.0)*(mY-mY/ptAigu->M[i]))) ;
  230.   }else {
  231.     // avec remplissage
  232.     // fill
  233.     prj->RP2->AreaInfo = prj->ai ;
  234.     InitArea(prj->ai, ptAigu->pt_buffer, ptAigu->points+2) ;
  235.     
  236.     AreaMove(prj->RP2, offset+(SHORT)mX+(ULONG)(cos(PI*(ptAigu->A[0]+p_time*ptAigu->angle+an_inc-90.0)/180.0)*(mX-mX/ptAigu->M[0])), 
  237.                               offset+(SHORT)mY+(ULONG)(sin(PI*(ptAigu->A[0]+p_time*ptAigu->angle+an_inc-90.0)/180.0)*(mY-mY/ptAigu->M[0]))) ;
  238.  
  239.     for(i = 0; i < ptAigu->points; i++) 
  240.       AreaDraw(prj->RP2, offset+(SHORT)mX+(ULONG)(cos(PI*(ptAigu->A[i]+p_time*ptAigu->angle+an_inc-90.0)/180.0)*(mX-mX/ptAigu->M[i])), 
  241.                                 offset+(SHORT)mY+(ULONG)(sin(PI*(ptAigu->A[i]+p_time*ptAigu->angle+an_inc-90.0)/180.0)*(mY-mY/ptAigu->M[i]))) ;
  242.       
  243.     AreaEnd(prj->RP2) ;
  244.   }
  245. }
  246. void init_bitmap(idWin * prj) {
  247.   /* initialize tmp rastport and bitmap
  248.    */
  249.   prj->tmpras = NewAllocMem(sizeof(struct TmpRas), MEMF_PUBLIC|MEMF_CLEAR) ;
  250.   prj->RP1 = NewAllocMem(sizeof(struct RastPort), MEMF_PUBLIC) ;
  251.   prj->RP2 = NewAllocMem(sizeof(struct RastPort), MEMF_PUBLIC) ; 
  252.   InitRastPort(prj->RP1) ;
  253.   InitRastPort(prj->RP2) ;
  254.   Xplane = prj->backWin.width ;
  255.   Yplane = prj->backWin.height ; 
  256.   prj->RP1->BitMap = AllocBitMap(Xplane, Yplane, prj->wb->RastPort.BitMap->Depth, BMF_CLEAR|BMF_DISPLAYABLE, NULL) ;
  257.   prj->RP2->BitMap = AllocBitMap(Xplane, Yplane, prj->wb->RastPort.BitMap->Depth, BMF_CLEAR|BMF_DISPLAYABLE, NULL) ;
  258.   tmpbitmap        = AllocRaster(Xplane, Yplane) ;
  259.   prj->RP2->TmpRas = (struct TmpRas *) InitTmpRas(prj->tmpras, tmpbitmap, RASSIZE(Xplane, Yplane)) ;
  260.   WaitBlit() ;
  261.   BltBitMapRastPort(prj->wb->RastPort.BitMap, prj->backWin.posX, prj->backWin.posY, prj->RP1, 0, 0, prj->backWin.width, prj->backWin.height, 0xc0) ;
  262.  
  263.  
  264. }
  265.  
  266. void free_bitmap(idWin * prj) {
  267.   if (prj->tmpras) NewFreeVec(prj->tmpras) ;
  268.   if (tmpbitmap) FreeRaster(tmpbitmap, Xplane, Yplane) ;
  269.   if (prj->RP1 && prj->RP1->BitMap) FreeBitMap(prj->RP1->BitMap) ;
  270.   if (prj->RP2 && prj->RP2->BitMap) FreeBitMap(prj->RP2->BitMap) ;
  271.   if (prj->RP1) NewFreeVec(prj->RP1) ;
  272.   if (prj->RP2) NewFreeVec(prj->RP2) ;
  273.   prj->RP1 = prj->RP2 = NULL ;
  274.   
  275. }
  276.  
  277.