home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / freedraft.tar.gz / freedraft.tar / FREEdraft-050298 / VIEWPORT / vdglcanvas.cpp < prev    next >
C/C++ Source or Header  |  1998-05-01  |  15KB  |  600 lines
  1. // vdglcanvas.cpp
  2.  
  3. // Copyright (C) 1997  Cliff Johnson                                       //
  4. //                                                                         //
  5. // This program is free software; you can redistribute it and/or           //
  6. // modify it under the terms of the GNU  General Public                    //
  7. // License as published by the Free Software Foundation; either            //
  8. // version 2 of the License, or (at your option) any later version.        //
  9. //                                                                         //
  10. // This software is distributed in the hope that it will be useful,        //
  11. // but WITHOUT ANY WARRANTY; without even the implied warranty of          //
  12. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU       //
  13. // General Public License for more details.                                //
  14. //                                                                         //
  15. // You should have received a copy of the GNU General Public License       //
  16. // along with this software (see COPYING.LIB); if not, write to the        //
  17. // Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. //
  18.  
  19. #include <iostream.h>
  20. #include <data_enum.h>
  21. #include <vdglcanvas.h>
  22. #include <vdcmdwin.h>
  23. #include <drawablegeom.h>
  24.  
  25. #include <point.h>
  26. #include <line.h>
  27. #include <selectstack.h>
  28. #include <vdapp_enum.h>
  29. #include <attrib_enum.h>
  30. #include <coreexception.h>
  31.  
  32.  
  33. //************************************************************************************
  34. void VDGLCanvas::LoadRegister(CanvasRegister* cr) 
  35. { 
  36.     canvasRegister = cr; 
  37. }
  38. //************************************************************************************
  39.  
  40.  
  41. //======================>>> testGLCanvasPane::VDGLCanvas<<<======================
  42. VDGLCanvas::VDGLCanvas(CanvasRegister* cr, unsigned int glmode): 
  43.     vBaseGLCanvasPane(glmode),
  44.     glState(Point(),1.,3.4)  // centered at zero, scale 1, 3.8 pixels/mm
  45. {
  46. // load register
  47.     canvasRegister = cr;
  48.  
  49. // set initial conditions
  50.     interfaceMode = NOMODE;
  51.     pickCount = 0;
  52.     initDone = 0;
  53. }
  54.  
  55. //======================>>> testGLCanvasPane::~VDGLCanvas<<<======================
  56. VDGLCanvas::~VDGLCanvas()
  57. {
  58. }
  59.  
  60. //======================>>> testGLCanvasPane::graphicsInit<<<======================
  61. void VDGLCanvas::graphicsInit(void)
  62. {
  63.     vBaseGLCanvasPane::graphicsInit();    // call the superclass first
  64.  
  65.     // glEnable(GL_DEPTH_TEST);
  66.     glClearDepth(1.0);
  67.     glClearColor(0.0,0.0,0.0,0.0);
  68.  
  69.     glMatrixMode(GL_PROJECTION);
  70.     glLoadIdentity();
  71.     SetOrtho2D();
  72.     glMatrixMode(GL_MODELVIEW);
  73.  
  74.     initDone = 1;
  75. }
  76.  
  77. //======================>>> testGLCanvasPane::MouseDown <<<======================
  78. void VDGLCanvas::MouseDown(int x, int y, int button)
  79. {
  80.  
  81. //cerr << "VDGLCanvas::MouseDown()" << endl;
  82.     switch(interfaceMode)
  83.     {
  84.     case PANNING:
  85.     case ZOOMIN:
  86.     case ZOOMOUT:
  87.         {
  88.         if(button != 1)break;
  89.         Point p = PickedCoord(x,y);
  90.  
  91.         pStack.Push(p);
  92.         break;
  93.         }
  94.  
  95.     case CENTERING:
  96.         {
  97.         if(button != 1)break;
  98.         glState.SetCenter(PickedCoord(x,y));
  99.             vglMakeCurrent();
  100.  
  101.         glMatrixMode(GL_PROJECTION);
  102.         glLoadIdentity();
  103.         SetOrtho2D();
  104.         glMatrixMode(GL_MODELVIEW);
  105.  
  106.         Redraw(0,0,0,0);
  107.         break;
  108.         }
  109.  
  110. //    case PICKING:
  111. //    case NOMODE:
  112. //        {
  113. //        SelectRegisteredEntities(x,y,button);
  114. //        interfaceMode = NOMODE;
  115. //        break;
  116. //        }
  117.     }
  118. // we are overriding the following:
  119. //    vBaseGLCanvasPane::MouseDown(x,y,button);
  120. }
  121.  
  122. //========================>>> VDGLCanvas::MouseUp <<<======================
  123. void VDGLCanvas::MouseUp(int x, int y, int button)
  124. {
  125.  
  126.     switch(interfaceMode)
  127.     {
  128.  
  129.     case PANNING:
  130.         {
  131.         if(button != 1)break;
  132.         Point p1 = pStack.Pop();
  133.         Point p2 = PickedCoord(x,y);
  134.         glState.SetCenter(glState.GetCenter() - p2 + p1);
  135.             vglMakeCurrent();
  136.  
  137.         glMatrixMode(GL_PROJECTION);
  138.         glLoadIdentity();
  139.         SetOrtho2D();
  140.         glMatrixMode(GL_MODELVIEW);
  141.  
  142.         Redraw(0,0,0,0);
  143.         break;
  144.         }
  145.  
  146.     case ZOOMIN:
  147.         {
  148.         if(button != 1)break;
  149.         Point p1 = pStack.Pop();
  150.         Point p2 = PickedCoord(x,y);
  151.         glState.ZoomIn(p1,p2,GetWidth(),GetHeight());
  152.             vglMakeCurrent();
  153.  
  154.         glMatrixMode(GL_PROJECTION);
  155.         glLoadIdentity();
  156.         SetOrtho2D();
  157.         glMatrixMode(GL_MODELVIEW);
  158.  
  159.         Redraw(0,0,0,0);
  160.         break;
  161.         }
  162.  
  163.     case ZOOMOUT:
  164.         {
  165.         if(button != 1)break;
  166.         Point p1 = pStack.Pop();
  167.         Point p2 = PickedCoord(x,y);
  168.         glState.ZoomOut(p1,p2,GetWidth(),GetHeight());
  169.             vglMakeCurrent();
  170.  
  171.         glMatrixMode(GL_PROJECTION);
  172.         glLoadIdentity();
  173.         SetOrtho2D();
  174.         glMatrixMode(GL_MODELVIEW);
  175.  
  176.         Redraw(0,0,0,0);
  177.         break;
  178.         }
  179.     case PICKING:
  180.     case NOMODE:
  181.         {
  182.         SelectRegisteredEntities(x,y,button);
  183.         interfaceMode = NOMODE;
  184.         break;
  185.         }
  186.     }
  187.  
  188. //   vBaseGLCanvasPane::MouseUp(x,y,button);
  189. }
  190.  
  191. //======================>>> VDGLCanvas::MouseMove <<<======================
  192. void VDGLCanvas::MouseMove(int x, int y, int button)
  193. {
  194. // animate the displacment line or selection box
  195.     switch(interfaceMode)
  196.     {
  197.  
  198.     case PANNING:
  199.         {
  200.         if(button != 1)break;
  201.         Point p1 = pStack.Top();
  202.         Point p2 = PickedCoord(x,y);
  203.             vglMakeCurrent();
  204.         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  205.         DrawRegisteredEntities();
  206.         SetAttributes(Attributes(FD_RED,FD_LINESTYLE_SOLID,1,0));
  207.             glBegin(GL_LINES);
  208.                     glVertex2f(p1[0],p1[1]);
  209.                     glVertex2f(p2[0],p2[1]);
  210.             glEnd();
  211.           vglFlush();
  212.         break;
  213.         }
  214.     case ZOOMIN:
  215.     case ZOOMOUT:
  216.         {
  217.         if(button != 1)break;
  218.         Point p1 = pStack.Top();
  219.         Point p2 = PickedCoord(x,y);
  220.             vglMakeCurrent();
  221.         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  222.         DrawRegisteredEntities();
  223.         SetAttributes(Attributes(FD_RED,FD_LINESTYLE_SOLID,1,0));
  224.         glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
  225.             glBegin(GL_POLYGON);
  226.                     glVertex2f(p1[0],p1[1]);
  227.                     glVertex2f(p2[0],p1[1]);
  228.                     glVertex2f(p2[0],p2[1]);
  229.                     glVertex2f(p1[0],p2[1]);
  230.             glEnd();
  231.         vglFlush();
  232.         break;
  233.         }
  234.     }
  235.  
  236.     vBaseGLCanvasPane::MouseMove(x,y,button);
  237. }
  238.  
  239. //=========================>>> VDGLCanvas::Redraw <<<======================
  240. void VDGLCanvas::Redraw(int x, int y, int w, int h)
  241. {
  242.     static int inRedraw = 0;
  243.  
  244.     if (inRedraw || !initDone)return;    // Don't draw until initialized
  245.  
  246.     inRedraw = 1;        // Don't allow recursive redraws.
  247.  
  248.     vglMakeCurrent();
  249.  
  250.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  251.  
  252.     DrawRegisteredEntities();
  253.  
  254.       vglFlush();
  255.  
  256.        inRedraw = 0;
  257.  
  258. }
  259.  
  260. //======================>>> virtual void VDGLCanvas::Resize <<<======================
  261. void VDGLCanvas::Resize(int w, int h)
  262. {
  263.         vBaseGLCanvasPane::Resize(w,h);
  264.  
  265.         vglMakeCurrent();
  266.  
  267.     glMatrixMode(GL_PROJECTION);
  268.     glLoadIdentity();
  269.     SetOrtho2D();
  270.     glMatrixMode(GL_MODELVIEW);
  271.  
  272.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  273.  
  274.     DrawRegisteredEntities();
  275.  
  276.       vglFlush();
  277. }
  278.  
  279. int VDGLCanvas::GetWidth()
  280. {
  281.     return vBaseGLCanvasPane::GetWidth();
  282. }
  283.  
  284. int VDGLCanvas::GetHeight()
  285. {
  286.     return vBaseGLCanvasPane::GetHeight();
  287. }
  288.  
  289. //=========================VDGLCanvas::DrawRegisteredEnttities===============
  290.  
  291. void VDGLCanvas::DrawRegisteredEntities()
  292. {
  293.  
  294. // pass through the list of handles, drawing each entity
  295.  
  296.     RegisteredEntity re;    // use a temporary copy for processing
  297.     float scale = glState.GetScale();
  298.  
  299.     if(!canvasRegister)return;          // if there is a list ( not NULL) ...
  300.  
  301.     canvasRegister->Init();    // reset the list iterator
  302.  
  303.     while(canvasRegister->NextItem(re) )
  304.     {
  305.         if(re.IsVisible())
  306.         {
  307.             if(re.IsHighlight())SetAttributes(Attributes(FD_MEDGREY,FD_LINESTYLE_SOLID,2,0));
  308.             else SetAttributes(re.GetAttributes());
  309.             re.Draw(scale);
  310.         }
  311.     }
  312. }
  313.  
  314. //=========================VDGLCanvas::SelectRegisteredEnttities===============
  315.  
  316. void VDGLCanvas::SelectRegisteredEntities(int x, int y, int button)
  317. {
  318. //cerr << "VDGLCanvas::SelectRegisteredEntities()" << endl;
  319.     RegisteredEntity re;    // use a temporary copy for processing
  320.  
  321.     if(!canvasRegister)return;    // if there is a list ( not NULL) ...
  322.  
  323. // prepare for picking 
  324.  
  325.     GLuint selectBuf[BUFSIZE];    
  326.     GLint hits;
  327.     GLint viewport[4];
  328.  
  329.     float scale = glState.GetScale();
  330.  
  331.     glGetIntegerv(GL_VIEWPORT,viewport);
  332.  
  333.     glSelectBuffer(BUFSIZE,selectBuf);
  334.     glRenderMode(GL_SELECT);
  335.  
  336.     glInitNames();
  337.     glPushName(0);
  338.  
  339.     glMatrixMode(GL_PROJECTION);
  340.     glPushMatrix();
  341.     glLoadIdentity();
  342.  
  343. // 6x6 pixel picking region near  cursor location 
  344.     gluPickMatrix(static_cast<GLfloat>(x), static_cast<GLfloat>(viewport[3] -y),
  345.     10.0,10.0,viewport);
  346.  
  347.     SetOrtho2D();
  348.  
  349. // draw the entities
  350.     canvasRegister->Init();    // reset the list iterator
  351.  
  352. // for each visible handle
  353.     while(canvasRegister->NextItem(re) ) re.Select(scale);
  354.  
  355. // collect the pick information
  356.     glMatrixMode(GL_PROJECTION);
  357.     glPopMatrix();
  358.     glFlush();
  359.  
  360.     hits = glRenderMode(GL_RENDER);
  361.  
  362.     SendCmdWindowResponse(x,y,button, hits,selectBuf);
  363. }
  364.  
  365.  
  366. //===========================================================================================
  367.  
  368.  
  369. void VDGLCanvas::SendCmdWindowResponse(int x, int y, int button, GLint hits,GLuint* selectBuf)
  370. {
  371.  
  372. //cerr << "VDGLCanvas::SendCmdWindowResponse()" << endl;
  373.  
  374. // process the selection records
  375.  
  376.     GLuint *ptr = selectBuf;
  377.     GLuint names;
  378.     RegisteredEntity re;
  379.     Handle htmp;
  380.     unsigned int hidx;
  381.  
  382.     SelectStack ss(button, PickedCoord(x,y));         // initialize selectstack
  383.  
  384.     canvasRegister->Init();    // reset the list iterator
  385.  
  386. // parse the hit records for the picked names
  387.  
  388. // for each hit...
  389.     for(int i=0; i<hits; i++){
  390.  
  391. // just skip through this stuff for our purposes
  392.         names = *ptr; // get number of names on stack when hit happened
  393.         ptr++; // to z1;
  394.         ptr++; // to z2;
  395.         ptr++; // to name lists
  396. //        for(unsigned int j=0;j<names;j++){
  397. // this name is what we want
  398. //            if(j == 0)
  399.         hidx = *ptr; // get the name (unsigned integer)
  400.         ptr++;
  401. //        } // get past this record
  402.  
  403. // find the registered entity with this handle idx - handles should be in the same order 
  404. // as in the canvas register
  405.         try
  406.         {
  407.             htmp = canvasRegister->GetHandleFromName(hidx);
  408.             ss.Push(htmp);
  409.         }
  410.         catch(CoreException & ce)
  411.         {
  412.             cerr << "CoreException Raised in VDGLCanvas::SendCmdWindowResponse()" << endl;
  413.             cerr <<  "       " << ce.what() << endl;
  414.         }
  415.     }
  416.  
  417. // all done. Send the selected handles back to the command window
  418.     (static_cast<vdCmdWindow*>(_parentWin))->CanvasPick(ss);
  419. }
  420.     
  421. //=========================VDGLCanvas::DrawLine===============
  422. //
  423. //void VDGLCanvas::DrawLine(const Line& l)
  424. //{
  425. //    //    Point p0 = Point(l.Origin()) + (10000. * Point(l.Direction()));
  426. //    //    Point p1 = Point(l.Origin()) - (10000. * Point(l.Direction()));
  427. //        Point p0 = l.Origin() + (10000. * l.Direction());
  428. //        Point p1 = l.Origin() - (10000. * l.Direction());
  429. //        glBegin(GL_LINES);
  430. //                glVertex2f(p0[0],p0[1]);
  431. //                glVertex2f(p1[0],p1[1]);
  432. //        glEnd();
  433. //}
  434. //
  435. //
  436. //----------------------VDGLCanvas::SetAttributes-----------------------
  437. void VDGLCanvas::SetAttributes(const Attributes& a) // loading a null register cancels display
  438. {
  439.     if(a == currentAttributes)return; // no reason to change anything
  440.  
  441. // we have only a small set of colors so we can implement useable selections by color
  442.  
  443.     if(!(a.GetColor() == currentAttributes.GetColor()))
  444.     {
  445.         float r,g,b;
  446.  
  447.         int colidx = a.GetColor();
  448.         r = vStdColors[colidx].r()/255.;
  449.         g = vStdColors[colidx].g()/255.;
  450.         b = vStdColors[colidx].b()/255.;
  451.         glColor3f(r,g,b);
  452.  
  453.     }
  454.  
  455.     unsigned short sx;
  456.     if(!((sx = a.GetLineStyle()) == currentAttributes.GetLineStyle()))
  457.     {
  458.     // linestippling
  459.         switch(sx)
  460.         {
  461.             case FD_LINESTYLE_SOLID:
  462.             case FD_LINESTYLE_LONGDASH:
  463.             case FD_LINESTYLE_DOTTED:
  464.                 glLineStipple(1,sx);
  465.                 break;
  466.             case FD_LINESTYLE_CHAIN:
  467.                 glLineStipple(2,sx);
  468.                 break;
  469.         }
  470.         glEnable(GL_LINE_STIPPLE);
  471.  
  472.     }
  473.     // process thicknesses  here
  474.  
  475.     if(!(a.GetThick() == currentAttributes.GetThick())){
  476.         glPointSize(a.GetThick());    
  477.         glLineWidth(a.GetThick());    
  478.     }
  479.     currentAttributes = a;
  480. }
  481.  
  482. //===========================VDGLCanvas::Register ==================
  483. //
  484. // add an entity with the window - and with the current canvasRegister
  485. //void VDGLCanvas::Register(const Handle& h, const Attributes& a, const Visibility& v)
  486. //{
  487. //    if(canvasRegister)canvasRegister->Register(h,a,v);
  488. //}
  489. //
  490. //===========================VDGLCanvas::CancelAction==================
  491.  
  492. void VDGLCanvas::CancelAction()
  493. {
  494.     interfaceMode = NOMODE;
  495.     pickCount = 0;
  496.     pStack.Clear();
  497. }
  498. //===========================VDGLCanvas::PickPan=========================
  499.  
  500. void VDGLCanvas::PickPan()
  501. {
  502.      interfaceMode = PANNING;
  503. }
  504.  
  505. //===============================VDGLCanvas::PickCenter====================
  506. void VDGLCanvas::PickCenter()
  507. {
  508.     interfaceMode = CENTERING;
  509. }
  510. //===============================VDGLCanvas::ZoomIn====================
  511. void VDGLCanvas::ZoomIn()
  512. {
  513.     interfaceMode = ZOOMIN;
  514. }
  515. //===============================VDGLCanvas::ZoomOut====================
  516. void VDGLCanvas::ZoomOut()
  517. {
  518.     interfaceMode = ZOOMOUT;
  519. }
  520. //===============================VDGLCanvas::ZoomOut====================
  521. void VDGLCanvas::ResetView()
  522. {
  523.     glState.viewCenter = Point();
  524.     glState.viewScale = 1.;
  525.     glMatrixMode(GL_PROJECTION);
  526.     glLoadIdentity();
  527.     SetOrtho2D();
  528.     glMatrixMode(GL_MODELVIEW);
  529.     Redraw(0,0,0,0);
  530. }
  531.  
  532. //void VDGLCanvas::SetGridLines(bool status, int step)
  533. //{
  534. //    drawGrid = status;
  535. //    if(drawGrid)gridStep = step;
  536. //}
  537.  
  538. //
  539. //void VDGLCanvas::DrawGridLines()
  540. //{
  541. //}
  542.  
  543. //void VDGLCanvas::LoadDrawableGeom(const DrawableGeom& dptr )
  544. //{
  545. //    for(int i=0; i< drawableRegister.size(); i++)
  546. //    {
  547. //    // replace if already in the register
  548. //        if( dptr.Type() == drawableRegister[i].Type())
  549. //        {
  550. //            drawableRegister[i] = dptr;
  551. //            return;
  552. //        }
  553. //    }
  554. //
  555. //    // not already in the list, add to the register.
  556. //    drawableRegister.push_back(dptr);
  557. //}
  558.  
  559. void VDGLCanvas::ModifyView(const vKey& keysym)
  560. {
  561. // zoom in, zoom out pan left,right,up,down
  562.     float scale = glState.GetScale();
  563.     Point center = glState.GetCenter();
  564.     float ppmm = glState.GetPPMM();
  565.     float w = GetWidth();
  566.     float h = GetHeight();
  567.  
  568.     switch(keysym)
  569.     {
  570.     //case KB_CenterView:
  571.         case KB_ZoomUp:
  572.                 glState.SetScale(scale * 1.1);
  573.         break;
  574.         case KB_ZoomDown:
  575.                 glState.SetScale(scale / 1.1);
  576.         break;
  577. // pan 10% of canvas size in each direction
  578.         case KB_LeftArrow: // geometry should move left, so the center goes to the right.
  579.         glState.SetCenter(center + Point(.1*w/(scale*ppmm),0));
  580.         break;
  581.         case KB_UpArrow:
  582.         glState.SetCenter(center - Point(0,.1*h/(scale*ppmm)));
  583.         break;
  584.         case KB_RightArrow:
  585.         glState.SetCenter(center - Point(.1*w/(scale*ppmm),0));
  586.         break;
  587.         case KB_DownArrow:
  588.         glState.SetCenter(center + Point(0,.1*h/(scale*ppmm)));
  589.         break;
  590.     }
  591.         vglMakeCurrent();
  592.  
  593.         glMatrixMode(GL_PROJECTION);
  594.         glLoadIdentity();
  595.         SetOrtho2D();
  596.         glMatrixMode(GL_MODELVIEW);
  597.  
  598.         Redraw(0,0,0,0);
  599. }
  600.