home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / OpenDoc / ProcessMap / $Sources / CPProcessMap.Image.cpp < prev    next >
Encoding:
Text File  |  1995-04-28  |  8.1 KB  |  351 lines  |  [TEXT/MPCC]
  1. //----------------------------------------------------------------------------------------
  2. // Imaging protocol
  3. //----------------------------------------------------------------------------------------
  4.  
  5. #ifndef _PROCESSMAP_
  6. #include "CPProcessMap.h"
  7. #endif
  8.  
  9. //----------------------------------------------------------------------------------------
  10.  
  11. void CPProcessMap::Draw(Environment* ev, ODFacet* facet, ODShape* invalidShape)
  12. {
  13.     // CodeWarrior: Cmd-Click or Search:Find Definition • Explain_Draw
  14.     EnteringMethod("\pCPProcessMap::Draw");
  15.     ODUnused(invalidShape);
  16.  
  17.     CFocus    foc(ev, facet);
  18.  
  19.     ODFrame*    frame     = facet->GetFrame(ev);
  20.     ODShape*    usedShape = frame->GetUsedShape(ev, kODNULL);
  21.     RgnHandle    rgn       = usedShape->GetQDRegion(ev);
  22.  
  23.     usedShape->Release(ev);
  24.  
  25.     Rect        rct     = (*rgn)->rgnBBox;
  26.     RgnHandle    oldClip = NULL;
  27.     RgnHandle    newClip;
  28.  
  29. //    ::PenSize(2, 2);
  30.  
  31.     if (frame->IsRoot(ev))
  32.     {
  33.         GrafPtr    curPort;
  34.  
  35.         ::GetPort(&curPort);
  36.         Rect r = curPort->portRect;
  37.         rctBar = r;
  38.         rctBar.right -= 15;
  39.         rctBar.bottom-= 15;
  40.         r.left = r.right  - 15;
  41.         r.top  = r.bottom - 15;
  42.         ::GetClip(oldClip = NewRgn());
  43.         ::ClipRect(&r);
  44.         ::DrawGrowIcon(curPort);
  45.         ::GetClip(newClip = ::NewRgn());
  46.         ::DiffRgn(oldClip, newClip, newClip);
  47.         ::SetClip(newClip);
  48.         ::DisposeRgn(newClip);
  49.         ::EraseRect(&(curPort->portRect));
  50.     }
  51.     else {
  52.         //::EraseRoundRect(&rct, 40, 40);
  53.         rctBar = rct;
  54.         ::EraseRect(&rct);
  55.     }
  56.  
  57.     if ( fHorizontal )
  58.     {
  59.         rctBar.left += 5;
  60.         rctBar.top  += 5;
  61.         rctBar.right-= 5;
  62.         rctBar.bottom = rctBar.top + 20;
  63.     }
  64.     else
  65.     {
  66.         rctBar.left  += 5;
  67.         rctBar.top   += 5;
  68.         rctBar.right  = rctBar.left + 20;
  69.         rctBar.bottom-= 5;
  70.     }
  71.     ::FrameRect(&rctBar);
  72.     DrawProcessMap(ev,facet);
  73.  
  74.     if (oldClip) {
  75.         ::SetClip(oldClip);
  76.         ::DisposeRgn(oldClip);
  77.     }
  78. }
  79.  
  80. void CPProcessMap::DrawProcessMap(Environment* ev, ODFacet* facet)
  81. {
  82. float f;
  83. short width,height;
  84. Rect rct;
  85. Pattern pattern;
  86.  
  87.     width = rctBar.right - rctBar.left;
  88.     height= rctBar.bottom- rctBar.top;
  89.  
  90.     rct = rctBar;
  91.  
  92. /* System Heap */
  93.     if ( fHorizontal )
  94.     {
  95.         rct.left = rctBar.left;
  96.         f = width;
  97.         f*= lSystemHeap;
  98.         f/= lLogicalSize;
  99.         rct.right= rct.left + f;
  100.     }
  101.     else
  102.     {
  103.         rct.bottom = rctBar.bottom;
  104.         f = height;
  105.         f*= lSystemHeap;
  106.         f/= lLogicalSize;
  107.         rct.top = rctBar.bottom - f;
  108.     }
  109.  
  110.     ::FrameRect(&rct);
  111.     ::InsetRect(&rct,1,1);
  112.     ::GetIndPattern(&pattern, 0, 1);
  113.     ::FillRect(&rct,&pattern);
  114.  
  115. /* Above BufPtr */
  116.     if ( fHorizontal )
  117.     {
  118.         rct.left = rctBar.left;
  119.         f = width;
  120.         f*= lAboveBufPtr;
  121.         f/= lLogicalSize;
  122.         rct.left+= f;
  123.         rct.right= rctBar.right;
  124.     }
  125.     else
  126.     {
  127.         rct.bottom = rctBar.bottom;
  128.         f = height;
  129.         f*= lAboveBufPtr;
  130.         f/= lLogicalSize;
  131.         rct.bottom -= f;
  132.         rct.top = rctBar.top;
  133.     }
  134.  
  135.     ::FrameRect(&rct);
  136.     ::InsetRect(&rct,1,1);
  137.     ::GetIndPattern(&pattern, 0, 2);
  138.     ::FillRect(&rct,&pattern);
  139.  
  140. #if 1
  141.     for(int i=0;i<sNumOfProcess;i++)
  142.     {
  143.         rct = rctBar;
  144.         if ( fHorizontal )
  145.         {
  146.             f = width;
  147.             f*= aProcesses[i].lStartAddress;
  148.             f/= lLogicalSize;
  149.             rct.left = rctBar.left + f;
  150.             f = width;
  151.             f*= aProcesses[i].lEndAddress;
  152.             f/= lLogicalSize;
  153.             rct.right= rctBar.left + f;
  154.         }
  155.         else
  156.         {
  157.             f = height;
  158.             f*= aProcesses[i].lStartAddress;
  159.             f/= lLogicalSize;
  160.             rct.bottom = rctBar.bottom - f;
  161.             f = height;
  162.             f*= aProcesses[i].lEndAddress;
  163.             f/= lLogicalSize;
  164.             rct.top    = rctBar.bottom - f;
  165.         }
  166.  
  167.         ::FrameRect(&rct);
  168.         ::InsetRect(&rct,1,1);
  169.         ::GetIndPattern(&pattern, 0, i+3);
  170.         ::FillRect(&rct,&pattern);
  171.     }
  172. #endif
  173. }
  174.  
  175. static void hexstring(Str255 str, short sLen, long lNum);
  176. static void hexstring(Str255 str, short sLen, long lNum)
  177. {
  178. char buff[30];
  179. short i;
  180. short nChar, nTMP;
  181. short sOff;
  182.  
  183.     for(i=0;;i++)
  184.     {
  185.         buff[i] = lNum%16;
  186.         if ( 10 <= buff[i] ) buff[i] = buff[i] - 10 + 'A';
  187.         else
  188.             buff[i] += '0';
  189.         lNum/=16;
  190.         if ( 0 == lNum )break;
  191.     }
  192.     nChar = i;
  193.     str[1] = '$';
  194.     sOff = 1;
  195.     nTMP = nChar;
  196.     while ( nTMP < sLen - 1 )
  197.     {
  198.         sOff ++;
  199.         str[sOff] = '0';
  200.         nTMP ++;
  201.     }
  202.     for(i=0;i<=nChar;i++, sOff++)
  203.     {
  204.         str[sOff] = buff[nChar-i];
  205.     }
  206.     str[0] = sLen;
  207. }
  208.  
  209. void CPProcessMap::DrawProcessName(StringPtr p, long lFrom, long lTo)
  210. {
  211. Point pt;
  212. short sWidth;
  213. Rect rct;
  214. Str255 str0;
  215.  
  216.     if ( ::EqualString(p, (StringPtr)PrevName, false, false) ) return;
  217.  
  218.     rct = rctBar;
  219.     if ( fHorizontal )
  220.     {
  221.         rct.top = rct.bottom +  1;
  222.         rct.bottom = rct.top +100;
  223.     }
  224.     else
  225.     {
  226.         rct.left = rct.right +  1;
  227.         rct.right= rct.right +300;
  228.     }
  229.     ::EraseRect(&rct);
  230.  
  231.     if ( fHorizontal )
  232.     {
  233.         sWidth = ::StringWidth(p);
  234.         pt.h = (rctBar.left + rctBar.right)/2 - sWidth/2;
  235.         pt.v = rctBar.bottom + sSysFontHeight;
  236.     }
  237.     else
  238.     {
  239.         pt.h = rctBar.right + 1;
  240.         pt.v = (rctBar.top + rctBar.bottom)/2;
  241.     }
  242.  
  243.     ::MoveTo(pt.h, pt.v);
  244.     ::DrawString(p);
  245.     if ( 0 != lFrom || 0 != lTo )
  246.     {
  247.         pt.v += (sSysFontHeight + sSysFontLeading);
  248.         ::MoveTo(pt.h, pt.v);
  249.         hexstring(str0,9,lFrom);
  250.         ::DrawString(str0);
  251.         ::DrawString("\p -> ");
  252.         hexstring(str0,9,lTo);
  253.         ::DrawString(str0);
  254.     }
  255.     ::BlockMoveData(p, PrevName, p[0] + 1);
  256. }
  257.  
  258. //----------------------------------------------------------------------------------------
  259.  
  260. void CPProcessMap::CanvasUpdated(Environment* ev, ODCanvas* canvas)
  261. {
  262.     // CodeWarrior: Cmd-Click or Search:Find Definition • Explain_CanvasUpdated
  263.     EnteringMethod("\pCPProcessMap::CanvasUpdated");
  264.     ODUnused(canvas);
  265. }
  266.  
  267. //----------------------------------------------------------------------------------------
  268.  
  269. void CPProcessMap::HighlightChanged(Environment* ev, ODFacet* facet)
  270. {
  271.     // CodeWarrior: Cmd-Click or Search:Find Definition • Explain_HighlightChanged
  272.     EnteringMethod("\pCPProcessMap::HighlightChanged");
  273.     ODUnused(facet);
  274. }
  275.  
  276. //----------------------------------------------------------------------------------------
  277.  
  278. ODULong CPProcessMap::GetPrintResolution(Environment* ev, ODFrame* frame)
  279. {
  280.     // CodeWarrior: Cmd-Click or Search:Find Definition • Explain_GetPrintResolution
  281.     EnteringMethod("\pCPProcessMap::GetPrintResolution");
  282.     ODUnused(frame);
  283.     return 0;
  284. }
  285.  
  286. //----------------------------------------------------------------------------------------
  287.  
  288. void CPProcessMap::FacetAdded(Environment* ev, ODFacet* facet)
  289. {
  290.     // CodeWarrior: Cmd-Click or Search:Find Definition • Explain_FacetAdded
  291.     EnteringMethod("\pCPProcessMap::FacetAdded");
  292.  
  293.     ODFrame* frame = facet->GetFrame(ev);
  294.     frame->RequestFrameShape(ev, this->PrivGetFrameShape(ev, frame), kODNULL);
  295.         // First, PrivGetFrameShape is called to calculate the frame
  296.         // shape we want.  However, we might not get it, due to the
  297.         // needs/constraints of the containing part.  Therefore, after
  298.         // calculating what we want, we see if we can get it by calling
  299.         // RequestFrameShape.
  300.         // RequestFrameShape either returns us what we passed it, or
  301.         // returns something else because it thinks it knows best.
  302.         // Either way, we then proceed with the returned result.
  303.         // Note that this means that we have to be prepared to deal
  304.         // with a frame shape other than we desire.
  305.  
  306.     this->PrivAdjustFacets(ev, frame);
  307.         // Given a new negotiated frame shape, adjust our facets based
  308.         // on it.  That's all there is to it.
  309.  
  310.     if (frame->IsRoot(ev))
  311.     {
  312.         ODBoolean succeeded = kODFalse;
  313.         succeeded = fSession->GetArbitrator(ev)->RequestFocusSet(ev, fFocusSet,frame);
  314.         if (succeeded)
  315.         {
  316.             this->FocusAcquired(ev, fSelectionFocus, frame);
  317.             this->FocusAcquired(ev, fMenuFocus, frame);
  318.             this->FocusAcquired(ev, fKeyFocus, frame);
  319.         }
  320.     }
  321. }
  322.  
  323. //----------------------------------------------------------------------------------------
  324.  
  325. void CPProcessMap::FacetRemoved(Environment* ev, ODFacet* facet)
  326. {
  327.     // CodeWarrior: Cmd-Click or Search:Find Definition • Explain_FacetRemoved
  328.     EnteringMethod("\pCPProcessMap::FacetRemoved");
  329. }
  330.  
  331. //----------------------------------------------------------------------------------------
  332.  
  333. void CPProcessMap::CanvasChanged(Environment* ev, ODFacet* facet)
  334. {
  335.     // CodeWarrior: Cmd-Click or Search:Find Definition • Explain_CanvasChanged
  336.     EnteringMethod("\pCPProcessMap::CanvasChanged");
  337.     ODUnused(facet);
  338. }
  339.  
  340. //----------------------------------------------------------------------------------------
  341.  
  342. void CPProcessMap::GeometryChanged(Environment* ev, ODFacet* facet,
  343.                                                    ODBoolean clipShapeChanged,
  344.                                                    ODBoolean externalTransformChanged)
  345. {
  346.     // CodeWarrior: Cmd-Click or Search:Find Definition • Explain_GeometryChanged
  347.     EnteringMethod("\pCPProcessMap::GeometryChanged");
  348.     ODUnused(facet);
  349.     ODUnused(clipShapeChanged);
  350.     ODUnused(externalTransformChanged);
  351. }