home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / VPR_DATA / DOGA / SOURCES / PASM.LZH / DISPLAY.CPP < prev    next >
C/C++ Source or Header  |  1996-07-12  |  44KB  |  1,471 lines
  1. /*  Project partsasm
  2.     Project Team DoGA
  3.     Copyright (c) 1995. All Rights Reserved.
  4.  
  5.     サブシステム:    partsasm.apx Application
  6.     ファイル:        display.cpp
  7.     作成者:          Taka2
  8.  
  9.  
  10.     概要
  11.     ====
  12.     TWinDisplay (TWindow) のインプリメンテーション用のソースファイル
  13. */
  14.  
  15. #include <owl\owlpch.h>
  16. #pragma hdrstop
  17.  
  18. #include "design.h"
  19. //#include "winframe.h"
  20. #include "display.h"
  21. #include "parts.h"
  22. #include "status.h"
  23. #include "syscolor.h"
  24. #include "log.h"
  25.  
  26. #include <stdio.h>
  27.  
  28. //
  29. // このアプリケーションで処理するすべてのメッセージ／コマンドの
  30. // 応答テーブルを作成する
  31. //
  32. DEFINE_RESPONSE_TABLE1(TWinDisplay, TWindow)
  33. //{{TWinDisplayRSP_TBL_BEGIN}}
  34.     EV_WM_LBUTTONDOWN,
  35.     EV_WM_MOUSEMOVE,
  36.     EV_WM_RBUTTONDOWN,
  37.     EV_WM_LBUTTONUP,
  38. //{{TWinDisplayRSP_TBL_END}}
  39. END_RESPONSE_TABLE;
  40.  
  41.  
  42. //{{TWinDisplay Implementation}}
  43.  
  44. #if 0
  45. static const TColor& cMarkerMove  = TColor::LtRed;
  46. static const TColor& cMarkerScale = TColor::LtMagenta;
  47. static const TColor& cMarkerRot   = TColor::LtBlue;
  48.  
  49. static const TColor& cGrid   = TColor::LtYellow;
  50. static const TColor& cGridZero = TColor::LtCyan;
  51. #endif
  52.  
  53. static const int minimumcube = 1, minimummarker = 4;
  54.  
  55. TWinDisplay::TWinDisplay(TWindow* parent, DesignData *d, SelectType sel, int x, int y, int w, int h):
  56.     TWindow(parent, 0, 0)
  57. {
  58.     SetBkgndColor(TColor::LtGray);
  59.  
  60.     designdata = d;
  61.     type = sel;
  62.     convmatrix = Matrix(1);
  63.  
  64.     markers = 0;
  65.  
  66.     if (sel == SelXY) {
  67.     } else if (sel == SelZX) {
  68.         convmatrix.v[1] = Vector(0.0, 0.0, -1.0);
  69.         convmatrix.v[2] = Vector(0.0, 1.0,  0.0);
  70.     } else if (sel == SelYZ) {
  71.         convmatrix.v[0] = Vector(0.0, 0.0, 1.0);
  72.         convmatrix.v[1] = Vector(1.0, 0.0, 0.0);
  73.         convmatrix.v[2] = Vector(0.0, 1.0, 0.0);
  74.     } else {
  75.  
  76.     }
  77.     Attr.X = x;
  78.     Attr.Y = y;
  79.     Attr.W = w;
  80.     Attr.H = h;
  81. }
  82.  
  83.  
  84.  
  85. TWinDisplay::~TWinDisplay ()
  86. {
  87.     Destroy();
  88.  
  89.     // INSERT>> デストラクタ用のコードはここに
  90.  
  91. }
  92.  
  93. static void getpoint(Matrix& mat, TPoint& pc, TPoint& vx, TPoint& vy, TPoint& vz, int& zx, int& zy, int& zz)
  94. {
  95.     vx = TPoint(int(mat.v[0].x),-int(mat.v[0].y));
  96.     vy = TPoint(int(mat.v[1].x),-int(mat.v[1].y));
  97.     vz = TPoint(int(mat.v[2].x),-int(mat.v[2].y));
  98.     pc = TPoint(int(mat.v[3].x),-int(mat.v[3].y));
  99.     zx = int(mat.v[0].z);
  100.     zy = int(mat.v[1].z);
  101.     zz = int(mat.v[2].z);
  102. }
  103.  
  104. static void draw5line(TDC& dc, TPoint& center, TPoint& offset, TPoint& p1, TPoint& p2)
  105. {
  106.     dc.MoveTo(center+offset+p1-p2);
  107.     dc.LineTo(center-offset+p1-p2);
  108.     dc.LineTo(center-offset-p1+p2);
  109.     dc.LineTo(center+offset-p1+p2);
  110.     dc.LineTo(center+offset+p1-p2);
  111.     dc.MoveTo(center+offset+p1+p2);
  112.     dc.LineTo(center-offset+p1+p2);
  113.  
  114.     dc.SelectObject(TPen(cBackGround,1,PS_DOT));
  115.     dc.MoveTo(center+offset+p1); dc.LineTo(center-offset+p1);
  116.     dc.MoveTo(center+offset+p2); dc.LineTo(center-offset+p2);
  117.     dc.MoveTo(center+p1-p2); dc.LineTo(center-p1+p2);
  118.  
  119. }
  120.  
  121. static void draw4line(TDC& dc, TPoint& center, TPoint& p1, TPoint& p2)
  122. {
  123.     dc.MoveTo(center+p1+p2);
  124.     dc.LineTo(center+p1-p2);
  125.     dc.LineTo(center-p1-p2);
  126.     dc.LineTo(center-p1+p2);
  127.     dc.LineTo(center+p1+p2);
  128.  
  129.     dc.SelectObject(TPen(cBackGround,1,PS_DOT));
  130.     dc.MoveTo(center+p1); dc.LineTo(center-p1);
  131.     dc.MoveTo(center+p2); dc.LineTo(center-p2);
  132.  
  133. }
  134.  
  135. static void draw9line(TDC& dc, TPoint& pc, TPoint& p1, TPoint& p2, TPoint& p3)
  136. {
  137.     dc.MoveTo(pc+p1+p2+p3);
  138.     dc.LineTo(pc+p1+p2-p3);
  139.     dc.LineTo(pc+p1-p2-p3);
  140.     dc.LineTo(pc+p1-p2+p3);
  141.     dc.LineTo(pc-p1-p2+p3);
  142.     dc.LineTo(pc-p1+p2+p3);
  143.     dc.LineTo(pc-p1+p2-p3);
  144.     dc.LineTo(pc+p1+p2-p3);
  145.     dc.MoveTo(pc-p1+p2+p3);
  146.     dc.LineTo(pc+p1+p2+p3);
  147.     dc.LineTo(pc+p1-p2+p3);
  148.  
  149.     dc.SelectObject(TPen(cBackGround,1,PS_DOT));
  150.     dc.MoveTo(pc+p1-p2); dc.LineTo(pc+p1+p2); dc.LineTo(pc-p1+p2);
  151.     dc.MoveTo(pc+p2-p3); dc.LineTo(pc+p2+p3); dc.LineTo(pc-p2+p3);
  152.     dc.MoveTo(pc+p3-p1); dc.LineTo(pc+p3+p1); dc.LineTo(pc-p3+p1);
  153. }
  154.  
  155. #if 0
  156. static int sign(int num, int weight)
  157. {
  158.     if (num < 0) {
  159.         return -weight;
  160.     } else if (num > 0) {
  161.         return weight;
  162.     } else {
  163.         return 0;
  164.     }
  165. }
  166.  
  167. static int sign(double num)
  168. {
  169.     if (num < 0.0) {
  170.         return -1;
  171.     } else if (num > 0.0) {
  172.         return 1;
  173.     }
  174.     return 0;
  175. }
  176. #endif
  177.  
  178. void TWinDisplay::Set4Marker(SelectType type, TPoint& pc, TPoint& p1, TPoint& p2)
  179. {
  180.     markers = 0;
  181.     markerpoint[markers]  = pc;
  182.     markertype[markers++] = SelMove;
  183.  
  184.     SelectType t1, t2;
  185.     if (type == SelXY) {
  186.         t1 = SelX;
  187.         t2 = SelY;
  188.     } else if (type == SelYZ) {
  189.         t1 = SelY;
  190.         t2 = SelZ;
  191.     } else {
  192.         t1 = SelZ;
  193.         t2 = SelX;
  194.     }
  195.     if (designdata->dragtype != DragRotOnly) {
  196.         markerpoint[markers]  = pc + p1;        markertype[markers++] = SelScale | t1;
  197.         markerpoint[markers]  = pc - p1;        markertype[markers++] = SelScale | t1;
  198.         markerpoint[markers]  = pc + p2;        markertype[markers++] = SelScale | t2;
  199.         markerpoint[markers]  = pc - p2;        markertype[markers++] = SelScale | t2;
  200.     }
  201.     if (designdata->dragtype != DragRotOnly) {
  202.         markerpoint[markers]  = pc + p1 + p2;    markertype[markers++] = SelRot | type;
  203.         markerpoint[markers]  = pc + p1 - p2;    markertype[markers++] = SelRot | type;
  204.         markerpoint[markers]  = pc - p1 + p2;    markertype[markers++] = SelRot | type;
  205.         markerpoint[markers]  = pc - p1 - p2;    markertype[markers++] = SelRot | type;
  206.     }
  207. }
  208.  
  209.  
  210. void TWinDisplay::Set5Marker(SelectType t3, SelectType /*t1*/, SelectType t2, TPoint& pc, TPoint& p3, TPoint& /*p1*/, TPoint& p2)
  211. {
  212.     markers = 0;
  213.     markerpoint[markers]  = pc;
  214.     markertype[markers++] = SelMove;
  215.  
  216.     if (designdata->dragtype != DragRotOnly) {
  217.         markerpoint[markers]  = pc + p2;             markertype[markers++] = SelScale | t2;
  218.         markerpoint[markers]  = pc + p3;             markertype[markers++] = SelScale | t3;
  219.         markerpoint[markers]  = pc - p3;            markertype[markers++] = SelScale | t3;
  220.     }
  221.     if (designdata->dragtype != DragScaleOnly) {
  222.         markerpoint[markers]  = pc + p2 + p3;       markertype[markers++] = SelRot | t2 | t3;
  223.         markerpoint[markers]  = pc + p2 - p3;       markertype[markers++] = SelRot | t2 | t3;
  224.     }
  225. }
  226.  
  227. void TWinDisplay::Set9Marker(SelectType t, TPoint& pc, TPoint& /*p1*/, TPoint& p2, TPoint& p3)
  228. {
  229.     markers = 0;
  230.     markerpoint[markers]  = pc;
  231.     markertype[markers++] = SelMove;
  232.  
  233.     SelectType /*t1, */t2, t3;
  234.     if (t == SelX) {
  235. //        t1 = SelX;
  236.         t2 = SelY;
  237.         t3 = SelZ;
  238.     } else if (t == SelY) {
  239. //        t1 = SelY;
  240.         t2 = SelZ;
  241.         t3 = SelX;
  242.     } else {
  243. //        t1 = SelZ;
  244.         t2 = SelX;
  245.         t3 = SelY;
  246.     }
  247.     if (designdata->dragtype != DragRotOnly) {
  248.         markerpoint[markers]  = pc      + p2;         markertype[markers++] = SelScale | t2;
  249.         markerpoint[markers]  = pc      + p3;        markertype[markers++] = SelScale | t3;
  250. //        markerpoint[markers]  = pc + p1 - p2;         markertype[markers++] = SelScale | t2;
  251. //        markerpoint[markers]  = pc + p1 - p3;         markertype[markers++] = SelScale | t3;
  252.     }
  253.     if (designdata->dragtype != DragScaleOnly) {
  254. //        markerpoint[markers]  = pc + p1 - p2 - p3;    markertype[markers++] = SelRot | t2 | t3;
  255.         markerpoint[markers]  = pc      + p2 + p3;     markertype[markers++] = SelRot | t2 | t3;
  256.         markerpoint[markers]  = pc      + p2 - p3;     markertype[markers++] = SelRot | t2 | t3;
  257.         markerpoint[markers]  = pc      - p2 + p3;     markertype[markers++] = SelRot | t2 | t3;
  258.     }
  259. }
  260.  
  261.  
  262. void TWinDisplay::DrawMarker(TDC& dc)
  263. {
  264.     for (int i = markers-1; i >= 0; --i) {
  265.         switch (markertype[i] & SelMode) {
  266.         case SelMove: case SelTarget:
  267.             dc.SelectObject(TPen(cMarkerMove));
  268.             dc.SelectObject(TBrush(cMarkerMove));
  269.             break;
  270.         case SelRot:
  271.             dc.SelectObject(TPen(cMarkerRot));
  272.             dc.SelectObject(TBrush(cMarkerRot));
  273.             break;
  274.         case SelScale:
  275.             dc.SelectObject(TPen(cMarkerScale));
  276.             dc.SelectObject(TBrush(cMarkerScale));
  277.             break;
  278.         }
  279.         dc.Rectangle(    markerpoint[i].x - markersize,
  280.                         markerpoint[i].y - markersize,
  281.                         markerpoint[i].x + markersize,
  282.                         markerpoint[i].y + markersize);
  283.     }
  284. }
  285.  
  286.  
  287. void TWinDisplay::ShowCamera(Matrix& m, int flag)
  288. {
  289.     Matrix mat;
  290.     mat = convmatrix * m;
  291.     TClientDC dc(*this);
  292.  
  293. //    dc.SetROP2(R2_NOT);
  294.     dc.SetROP2(R2_XORPEN);
  295.  
  296.     TPoint pc, vx, vy, vz;
  297.     int zx, zy, zz;
  298.     getpoint(mat, pc, vx, vy, vz, zx, zy, zz);
  299.  
  300.     pc.x += Attr.W/2;
  301.     pc.y += Attr.H/2;
  302.  
  303.     dc.SelectObject(TPen(cWireCameraSelect));
  304.     dc.MoveTo(pc);    dc.LineTo(pc+vx);
  305.     if (vy.x == 0 && vy.y == 0) {
  306.         dc.MoveTo(pc);    dc.LineTo(pc+vx+vz);
  307.         dc.MoveTo(pc);    dc.LineTo(pc+vx-vz);
  308.     } else if (vz.x == 0 && vz.y == 0) {
  309.         dc.MoveTo(pc);    dc.LineTo(pc+vx+vy);
  310.         dc.MoveTo(pc);    dc.LineTo(pc+vx-vy);
  311.     } else {
  312.         dc.MoveTo(pc);    dc.LineTo(pc+vx+vy+vz);
  313.         dc.MoveTo(pc);    dc.LineTo(pc+vx+vy-vz);
  314.         dc.MoveTo(pc);    dc.LineTo(pc+vx-vy+vz);
  315.         dc.MoveTo(pc);    dc.LineTo(pc+vx-vy-vz);
  316.     }
  317.     if (flag) {
  318.         dc.SetROP2(R2_COPYPEN);
  319. //        DrawMarker(dc);
  320.         markers = 0;
  321.         markerpoint[markers] = pc;
  322.         markertype[markers++] = SelMove;
  323.         markerpoint[markers] = pc+vx;
  324.         markertype[markers++] = SelTarget;
  325.         DrawMarker(dc);
  326.     }
  327. }
  328.  
  329. void TWinDisplay::ShowCube(Matrix& m, int flag, SelectType t)
  330. {
  331.  
  332. //logprintf("ShowCube:\n");
  333. //logprintf("(%6.3lf %6.3lf %6.3lf %6.3lf)\n", m.v[0].x, m.v[1].x, m.v[2].x, m.v[3].x);
  334. //logprintf("(%6.3lf %6.3lf %6.3lf %6.3lf)\n", m.v[0].y, m.v[1].y, m.v[2].y, m.v[3].y);
  335. //logprintf("(%6.3lf %6.3lf %6.3lf %6.3lf)\n", m.v[0].z, m.v[1].z, m.v[2].z, m.v[3].z);
  336.  
  337.  
  338.     Matrix mat;
  339.     mat = convmatrix * m;
  340.     TClientDC dc(*this);
  341.  
  342. //    dc.SetROP2(R2_NOT);
  343. //    dc.SetROP2(R2_XORPEN);
  344. //    dc.SelectObject(TPen(cWireCube));
  345.     dc.SetROP2(R2_NOTXORPEN);
  346.     dc.SelectObject(TPen(cBackGround));
  347.     dc.SetBkMode(TRANSPARENT);
  348.  
  349.     TPoint pc, vx, vy, vz;
  350.     int zx, zy, zz;
  351.     getpoint(mat, pc, vx, vy, vz, zx, zy, zz);
  352.  
  353.     pc.x += Attr.W/2;
  354.     pc.y += Attr.H/2;
  355.  
  356.     if (zx < 0) vx = -vx;
  357.     if (zy < 0) vy = -vy;
  358.     if (zz < 0) vz = -vz;
  359.  
  360.     if (-minimumcube <= zx && zx <= minimumcube) {
  361.         if (-minimumcube <= zy && zy <= minimumcube) {
  362.             draw4line(dc, pc, vx, vy);
  363.         } else if (-minimumcube <= zz && zz <= minimumcube) {
  364.             draw4line(dc, pc, vz, vx);
  365.         } else {
  366.             draw5line(dc, pc, vx, vy, vz);
  367.         }
  368.     } else if (-minimumcube <= zy && zy <= minimumcube) {
  369.         if (-minimumcube <= zz && zz <= minimumcube) {
  370.             draw4line(dc, pc, vy, vz);
  371.         } else {
  372.             draw5line(dc, pc, vy, vz, vx);
  373.         }
  374.     } else if (-minimumcube <= zz && zz <= minimumcube) {
  375.         draw5line(dc, pc, vz, vx, vy);
  376.     } else {
  377.         draw9line(dc, pc, vx, vy, vz);
  378.     }
  379.     if (flag) {
  380.         if (-minimummarker <= zx && zx <= minimummarker) {
  381.             if (-minimummarker <= zy && zy <= minimummarker) {
  382.                 Set4Marker(SelXY, pc, vx, vy);
  383.             } else if (-minimummarker <= zz && zz <= minimummarker) {
  384.                 Set4Marker(SelZX, pc, vz, vx);
  385.             } else {
  386.                 if (t & SelZ) {
  387.                     Set5Marker(SelX, SelZ, SelY, pc, vx, vz, vy);
  388.                 } else {
  389.                     Set5Marker(SelX, SelY, SelZ, pc, vx, vy, vz);
  390.                 }
  391.             }
  392.         } else if (-minimummarker <= zy && zy <= minimummarker) {
  393.             if (-minimummarker <= zz && zz <= minimummarker) {
  394.                 Set4Marker(SelYZ, pc, vy, vz);
  395.             } else {
  396.                 if (t & SelZ) {
  397.                     Set5Marker(SelY, SelZ, SelX, pc, vy, vz, vx);
  398.                 } else {
  399.                     Set5Marker(SelY, SelX, SelZ, pc, vy, vx, vz);
  400.                 }
  401.             }
  402.         } else if (-minimummarker <= zz && zz <= minimummarker) {
  403.             if (t & SelY) {
  404.                 Set5Marker(SelZ, SelY, SelX, pc, vz, vy, vx);
  405.             } else {
  406.                 Set5Marker(SelZ, SelX, SelY, pc, vz, vx, vy);
  407.             }
  408.         } else {
  409.             if (t & SelX) {
  410.                 Set9Marker(SelX, pc, vx, vy, vz);
  411.             } else if (t & SelY) {
  412.                 Set9Marker(SelY, pc, vy, vz, vx);
  413.             } else {
  414.                 Set9Marker(SelZ, pc, vz, vx, vy);
  415.             }
  416.         }
  417. #if 0
  418.         if (designdata->select == designdata->combined) {
  419.             int i, j;
  420.             for(i = j = 0; i < markers; i++) {
  421.                 if ((markertype[i] & SelScale) == 0) {
  422.                     if (i != j) {
  423.                         markerpoint[j] = markerpoint[i];
  424.                         markertype[j] = markertype[i];
  425.                     }
  426.                     j++;
  427.                 }
  428.             }
  429.             markers = j;
  430.         }
  431. #endif
  432.         dc.SetROP2(R2_COPYPEN);
  433.         DrawMarker(dc);
  434.     }
  435. }
  436.  
  437. int TWinDisplay::GetPositionDistance(Parts *parts, TPoint &point)
  438. {
  439.     int cx, cy;
  440.  
  441.     cx = Attr.W / 2;
  442.     cy = Attr.H / 2;
  443.  
  444.     Matrix m = designdata->GetMatrix(parts);
  445.     TPoint p(0,0);
  446.     if ( type == SelXY) {
  447.         p.x = cx + m.v[3].x;
  448.         p.y = cy - m.v[3].y;
  449.     } else if (type == SelYZ) {
  450.         p.x = cx + m.v[3].y;
  451.         p.y = cy - m.v[3].z;
  452.     } else if (type == SelZX) {
  453.         p.x = cx + m.v[3].x;
  454.         p.y = cy - m.v[3].z;
  455.     }
  456.     int distance;
  457.     if (p.x < point.x) {
  458.         distance = point.x - p.x;
  459.     } else {
  460.         distance = p.x - point.x;
  461.     }
  462.     if (p.y < point.y) {
  463.         distance += point.y - p.y;
  464.     } else {
  465.         distance += p.y - point.y;
  466.     }
  467.     return distance;
  468. }
  469.  
  470. static int distance(TPoint& p1, TPoint& p2)
  471. {
  472.     int dist;
  473.     TPoint p = p1 - p2;
  474.     if (p.x < 0) {
  475.         dist = -p.x;
  476.     } else {
  477.         dist = p.x;
  478.     }
  479.     if (p.y < 0) {
  480.         dist += -p.y;
  481.     } else {
  482.         dist += p.y;
  483.     }
  484.     return dist;
  485. }
  486.  
  487. void TWinDisplay::Paint (TDC& dc, BOOL erase, TRect& rect)
  488. {
  489.     TWindow::Paint(dc, erase, rect);
  490.  
  491.     // INSERT>> 追加のコードはここに
  492.  
  493.     SelectType t;
  494.     if (type == SelYZ) {
  495.         t = SelX;
  496.     } else if (type == SelZX) {
  497.         t = SelY;
  498.     } else {
  499.         t = SelZ;
  500.     }
  501.     designdata->Redraw(t);
  502.  
  503. #if 0
  504.     if (type == SelYZ) {
  505.         dc.TextOut(0,0,"前");
  506.     } else if (type == SelZX) {
  507.         dc.TextOut(0,0,"横");
  508.     } else {
  509.         dc.TextOut(0,0,"上");
  510.     }
  511. #endif
  512. }
  513.  
  514.  
  515. void TWinDisplay::EvLButtonDown (UINT modKeys, TPoint& point)
  516. {
  517.     TWindow::EvLButtonDown(modKeys, point);
  518.  
  519.     // INSERT>> 追加コードはここに
  520.  
  521.     if (designdata->zoommode == ZoomSelect) {
  522.         Zoom(modKeys, point);
  523.         return;
  524.     }
  525.     designdata->selectstatus = SelMode;
  526.     designdata->drag_point = point;
  527.     SetCapture();
  528. }
  529.  
  530. void TWinDisplay::OpSelect(UINT /*modKeys*/, TPoint& point, Vector& /*v*/)
  531. {
  532.  
  533.     for (int i = 0; i < markers; ++i) {
  534.         if (distance(designdata->drag_point, markerpoint[i]) < markersize * 2) {
  535.             break;
  536.         }
  537.     }
  538.     if (i < markers) {
  539.         double rx, ry, len;
  540.         designdata->selectstatus = markertype[i];
  541.         designdata->GetCubeMatrix(designdata->select, designdata->drag_move, designdata->drag_rot, designdata->drag_scale);
  542.         designdata->drag_mat = designdata->drag_move * designdata->drag_rot * designdata->drag_scale;
  543.         switch (markertype[i] & SelMode) {
  544.         case SelRot:
  545.             if ((markertype[i] & SelXYZ) == SelNone) {
  546.                 designdata->selectstatus = SelRot;
  547.                 rx = double( point.y - markerpoint[0].y);
  548.                 ry = double(-point.x + markerpoint[0].x);
  549.                 if (type == SelZX) {
  550.                     rx = -rx;
  551.                     ry = -ry;
  552.                 }
  553.             } else if (markertype[i] == (SelRot | SelX) || markertype[i] == (SelRot | SelY) || markertype[i] == (SelRot | SelZ)){
  554.                 Matrix m = designdata->drag_mat;
  555.                 m.v[0] -= m.v[3];
  556.                 m.v[1] -= m.v[3];
  557.                 m.v[2] -= m.v[3];
  558.                 if (designdata->drag_scale.v[0].x < 0.0) m.v[0] = -1.0 * m.v[0];
  559.                 if (designdata->drag_scale.v[1].y < 0.0) m.v[1] = -1.0 * m.v[1];
  560.                 if (designdata->drag_scale.v[2].z < 0.0) m.v[2] = -1.0 * m.v[2];
  561.                 m = convmatrix * m;
  562.                 Vector v;
  563.                 switch (markertype[i] & SelXYZ) {
  564.                 case SelX: v = m.v[0]; break;
  565.                 case SelY: v = m.v[1]; break;
  566.                 case SelZ: v = m.v[2]; break;
  567.                 }
  568.                 rx = v.y;
  569.                 ry = v.x;
  570.             } else {
  571.                 Matrix m = convmatrix * designdata->drag_rot;
  572.                 Vector v;
  573.                 rx = designdata->drag_px[0] = (double)(point.x - markerpoint[0].x);
  574.                 ry = designdata->drag_px[1] = (double)(point.y - markerpoint[0].y);
  575.                 switch (markertype[i] & SelXYZ) {
  576.                 case SelYZ: v = m.v[0]; break;
  577.                 case SelZX: v = m.v[1]; break;
  578.                 case SelXY: v = m.v[2]; break;
  579.                 }
  580. #if 0
  581. switch (markertype[i] & SelXYZ) {
  582.     case SelYZ: logprintf("SelYZ:\n"); break;
  583.     case SelZX: logprintf("SelZX:\n"); break;
  584.     case SelXY: logprintf("SelXY:\n"); break;
  585. }
  586. logprintf("(%6.3lf %6.3lf):(%6.3lf)\n", rx, ry, v.z);
  587. #endif
  588.                 if (v.z > 0.0) {
  589.                     designdata->drag_py[0] =  designdata->drag_px[1];
  590.                     designdata->drag_py[1] = -designdata->drag_px[0];
  591.                 } else {
  592.                     designdata->drag_py[0] = -designdata->drag_px[1];
  593.                     designdata->drag_py[1] =  designdata->drag_px[0];
  594.                 }
  595.                 designdata->drag_point = markerpoint[0];
  596.             }
  597.             len = rx*rx+ry*ry;
  598.             designdata->drag_rx = rx / len * deg(90.0);
  599.             designdata->drag_ry = ry / len * deg(90.0);
  600.             break;
  601.         case SelScale:
  602.             designdata->drag_point = markerpoint[0];
  603.             rx = double(point.x - markerpoint[0].x);
  604.             ry = double(point.y - markerpoint[0].y);
  605.             len = rx * rx + ry * ry;
  606.             designdata->drag_rx = rx / len;
  607.             designdata->drag_ry = ry / len;
  608.             break;
  609.         }
  610.     }
  611. }
  612.  
  613. void TWinDisplay::OpSelectMove(UINT /*modKeys*/, TPoint& point, Vector& /*v*/)
  614. {
  615.     Parts *p = NULL;;
  616.     for (p = designdata->parts; p != NULL; p = p -> next) {
  617.         if (GetPositionDistance(p, point) < markersize*3) {
  618.             break;
  619.         }
  620.     }
  621.     if (p == NULL && GetPositionDistance(designdata->camera, point) < markersize*3) {
  622.         p = designdata->camera;
  623.     }
  624.     if (p != NULL) {
  625.         designdata->SelectParts(p);
  626.         designdata->Redraw();
  627.         designdata->selectstatus = SelMove;
  628.         designdata->GetCubeMatrix(designdata->select, designdata->drag_move, designdata->drag_rot, designdata->drag_scale);
  629.         designdata->drag_mat = designdata->drag_move * designdata->drag_rot * designdata->drag_scale;
  630.     }
  631. }
  632.  
  633. void TWinDisplay::DisplayCursorObject(UINT /*modKeys*/, TPoint& point)
  634. {
  635.     Parts *p;
  636.     for (p = designdata->parts; p != NULL; p = p->next) {
  637.         if (GetPositionDistance(p, point) < markersize*2) {
  638.             break;
  639.         }
  640.     }
  641.     if (p == NULL && GetPositionDistance(designdata->camera, point) < markersize*2) {
  642.         p = designdata->camera;
  643.     }
  644.     designdata->Status->DisplayStatusTemp(p);
  645. }
  646.  
  647.  
  648. static void SelectOne(Vector& v)
  649. {
  650.     double px, py, pz;
  651.     if ((px = v.x) < 0.0) px = -px;
  652.     if ((py = v.y) < 0.0) py = -py;
  653.     if ((pz = v.z) < 0.0) pz = -pz;
  654.     if (px > py && px > pz) {
  655.         v.y = v.z = 0.0;
  656.     } else if (py > pz) {
  657.         v.x = v.z = 0.0;
  658.     } else {
  659.         v.x = v.y = 0.0;
  660.     }
  661. }
  662.  
  663. static void engrid(Vector& v, int grid)
  664. {
  665.     if (v.x > 0) {
  666.         v.x =  (double)( ((long)( v.x) + grid/2) / grid) * (double) grid;
  667.     } else {
  668.         v.x = -(double)( ((long)(-v.x) + grid/2) / grid) * (double) grid;
  669.     }
  670.     if (v.y > 0) {
  671.         v.y =  (double)( ((long)( v.y) + grid/2) / grid) * (double) grid;
  672.     } else {
  673.         v.y = -(double)( ((long)(-v.y) + grid/2) / grid) * (double) grid;
  674.     }
  675.     if (v.z > 0) {
  676.         v.z =  (double)( ((long)( v.z) + grid/2) / grid) * (double) grid;
  677.     } else {
  678.         v.z = -(double)( ((long)(-v.z) + grid/2) / grid) * (double) grid;
  679.     }
  680. }
  681.  
  682. static void limit(Vector& v)
  683. {
  684.     if (v.x >  limitdim) v.x =  limitdim;
  685.     if (v.x < -limitdim) v.x = -limitdim;
  686.     if (v.y >  limitdim) v.y =  limitdim;
  687.     if (v.y < -limitdim) v.y = -limitdim;
  688.     if (v.z >  limitdim) v.z =  limitdim;
  689.     if (v.z < -limitdim) v.z = -limitdim;
  690. }
  691.  
  692. void TWinDisplay::OpDrag(UINT modKeys, TPoint& point, Vector& v)
  693. {
  694.     Matrix nmat;
  695.     Vector tmpvec;
  696.     double r;
  697.     double px, py;
  698.     switch (designdata->selectstatus & SelMode) {
  699.     case SelMove:
  700.         if (modKeys & MK_SHIFT) {
  701.             SelectOne(v);
  702.         }
  703.         tmpvec = designdata->select->position + (1.0/designdata->displayscale)*v;
  704.         limit(tmpvec);
  705.         if (((modKeys & MK_CONTROL) != 0) ^ (designdata->gridflag != FALSE)) {
  706.             engrid(tmpvec, designdata->gridspacing);
  707.             if (v.x == 0.0) tmpvec.x = designdata->select->position.x;
  708.             if (v.y == 0.0) tmpvec.y = designdata->select->position.y;
  709.             if (v.z == 0.0) tmpvec.z = designdata->select->position.z;
  710.         }
  711.         if (designdata->select == designdata->camera) {
  712.             nmat = (designdata->camera->target - tmpvec) ^ Vector(0,0,1);
  713.  
  714.             {
  715.                 double l0x = (designdata->camera->target - tmpvec).length();
  716.                 double l0y = l0x*tan(designdata->camera->angle/2.0);
  717.                 double l0z = l0y * 3 / 4;
  718.                 nmat = designdata->drag_move.move(tmpvec-designdata->select->position)
  719.                          * nmat * Matrix::m_scale(Vector(l0x, l0y, l0z));
  720.             }
  721.         } else {
  722.             nmat = designdata->drag_move.move(tmpvec-designdata->select->position)
  723.                  * designdata->drag_rot * designdata->drag_scale;
  724.         }
  725.         designdata->Status->DisplayPosition(tmpvec);
  726.         designdata->ShowCube(designdata->drag_mat, nmat);
  727.         designdata->drag_mat = nmat;
  728.         break;
  729.     case SelTarget:
  730.         if (modKeys & MK_SHIFT) {
  731.             SelectOne(v);
  732.         }
  733.         tmpvec = designdata->camera->target + (1.0/designdata->displayscale) * v;
  734.         limit(tmpvec);
  735.         if (((modKeys & MK_CONTROL) != 0) ^ (designdata->gridflag != FALSE)) {
  736.             engrid(tmpvec, designdata->gridspacing);
  737.             if (v.x == 0.0) tmpvec.x = designdata->camera->target.x;
  738.             if (v.y == 0.0) tmpvec.y = designdata->camera->target.y;
  739.             if (v.z == 0.0) tmpvec.z = designdata->camera->target.z;
  740.         }
  741.         nmat = (tmpvec - designdata->camera->position) ^ Vector(0.0, 0.0, 1.0);
  742.         {
  743.             double l0x = (tmpvec - designdata->camera->position).length();
  744.             double l0y = l0x*tan(designdata->camera->angle/2.0);
  745.             double l0z = l0y * 3 / 4;
  746.             nmat = designdata->drag_move * nmat * Matrix::m_scale(Vector(l0x, l0y, l0z));
  747.         }
  748.         designdata->Status->DisplayTarget(tmpvec);
  749.         designdata->ShowCube(designdata->drag_mat, nmat);
  750.         designdata->drag_mat = nmat;
  751.         break;
  752.     case SelRot:
  753.         r = designdata->drag_rx * (point.x - designdata->drag_point.x)
  754.           + designdata->drag_ry * (point.y - designdata->drag_point.y);
  755.         switch (designdata->selectstatus & SelXYZ) {
  756.         case SelNone:
  757.             switch (type) {
  758.             case SelXY: nmat = Matrix(1).rotz(r); break;
  759.             case SelYZ: nmat = Matrix(1).rotx(r); break;
  760.             case SelZX: nmat = Matrix(1).roty(r); break;
  761.             }
  762.             nmat = nmat * designdata->drag_rot;
  763.             break;
  764.         case SelX: nmat = designdata->drag_rot.rotx(r); break;
  765.         case SelY: nmat = designdata->drag_rot.roty(r); break;
  766.         case SelZ: nmat = designdata->drag_rot.rotz(r); break;
  767.         case SelXY:
  768.             px = designdata->drag_px[0] * (point.x - designdata->drag_point.x)
  769.                + designdata->drag_px[1] * (point.y - designdata->drag_point.y);
  770.             py = designdata->drag_py[0] * (point.x - designdata->drag_point.x)
  771.                + designdata->drag_py[1] * (point.y - designdata->drag_point.y);
  772.             if (-minimumdouble < px && px < minimumdouble
  773.              && -minimumdouble < py && py < minimumdouble) {
  774.                 nmat = designdata->drag_rot;
  775.             } else {
  776.                 nmat = designdata->drag_rot.rotz(atan2(py, px));
  777.             }
  778.             break;
  779.         case SelYZ:
  780.             px = designdata->drag_px[0] * (point.x - designdata->drag_point.x)
  781.                + designdata->drag_px[1] * (point.y - designdata->drag_point.y);
  782.             py = designdata->drag_py[0] * (point.x - designdata->drag_point.x)
  783.                + designdata->drag_py[1] * (point.y - designdata->drag_point.y);
  784.             if (-minimumdouble < px && px < minimumdouble
  785.              && -minimumdouble < py && py < minimumdouble) {
  786.                 nmat = designdata->drag_rot;
  787.             } else {
  788.                 nmat = designdata->drag_rot.rotx(atan2(py, px));
  789.             }
  790.             break;
  791.         case SelZX:
  792.             px = designdata->drag_px[0] * (point.x - designdata->drag_point.x)
  793.                + designdata->drag_px[1] * (point.y - designdata->drag_point.y);
  794.             py = designdata->drag_py[0] * (point.x - designdata->drag_point.x)
  795.                + designdata->drag_py[1] * (point.y - designdata->drag_point.y);
  796.             if (-minimumdouble < px && px < minimumdouble
  797.              && -minimumdouble < py && py < minimumdouble) {
  798.                 nmat = designdata->drag_rot;
  799.             } else {
  800.                 nmat = designdata->drag_rot.roty(atan2(py, px));
  801.             }
  802.             break;
  803.         }
  804.         tmpvec = nmat.GetRotation();
  805.         if (((modKeys & MK_CONTROL) != 0) ^ (designdata->gridflag != FALSE)) {
  806.             tmpvec *= rad(1.0);
  807.             engrid(tmpvec, designdata->rotspacing);
  808.             tmpvec *= deg(1.0);
  809.             nmat = Matrix(1).rotz(tmpvec.z).roty(tmpvec.y).rotx(tmpvec.x);
  810.         }
  811.  
  812.         nmat = designdata->drag_move * nmat * designdata->drag_scale;
  813.         designdata->Status->DisplayRotation(tmpvec);
  814.         designdata->ShowCube(designdata->drag_mat, nmat);
  815.         designdata->drag_mat = nmat;
  816.         break;
  817.     case SelScale:
  818.         r = designdata->drag_rx * (point.x - designdata->drag_point.x)
  819.           + designdata->drag_ry * (point.y - designdata->drag_point.y);
  820.         tmpvec = designdata->select->scale;
  821.         nmat = Matrix(1);
  822.         if ((modKeys & MK_SHIFT) || designdata->select == designdata->combined) {
  823.             nmat.v[0].x = nmat.v[1].y = nmat.v[2].z = r;
  824.             tmpvec *= r;
  825.         } else {
  826.             if (designdata->selectstatus & SelX) { nmat.v[0].x = r; tmpvec.x *= r;}
  827.             if (designdata->selectstatus & SelY) { nmat.v[1].y = r; tmpvec.y *= r;}
  828.             if (designdata->selectstatus & SelZ) { nmat.v[2].z = r; tmpvec.z *= r;}
  829.         }
  830.         if (((modKeys & MK_CONTROL) != 0) ^ (designdata->gridflag != FALSE)) {
  831.             Vector org = tmpvec;
  832.             tmpvec *= scalespacingfactor;
  833.             engrid(tmpvec, designdata->scalespacing);
  834.             tmpvec *= (1.0/scalespacingfactor);
  835.             if ((modKeys & MK_SHIFT) == 0 && designdata->select != designdata->combined) {
  836.                 if ((designdata->selectstatus & SelX)==0) tmpvec.x = org.x;
  837.                 if ((designdata->selectstatus & SelY)==0) tmpvec.y = org.y;
  838.                 if ((designdata->selectstatus & SelZ)==0) tmpvec.z = org.z;
  839.             }
  840.             if (org.x != 0.0) nmat.v[0].x *= tmpvec.x / org.x;
  841.             if (org.y != 0.0) nmat.v[1].y *= tmpvec.y / org.y;
  842.             if (org.z != 0.0) nmat.v[2].z *= tmpvec.z / org.z;
  843.         }
  844.         nmat = designdata->drag_move * designdata->drag_rot * designdata->drag_scale * nmat;
  845.         designdata->ShowCube(designdata->drag_mat, nmat);
  846.         designdata->drag_mat = nmat;
  847.         designdata->Status->DisplayScale(tmpvec);
  848.         break;
  849.     case SelCombined:
  850.         {
  851.             TClientDC dc(*this);
  852.             dc.SetROP2(R2_NOTXORPEN);
  853.             dc.SelectObject(TPen(cBackGround));
  854.  
  855.             dc.MoveTo(designdata->tmp_point.x,  designdata->tmp_point.y);
  856.             dc.LineTo(designdata->tmp_point.x,  designdata->drag_point.y);
  857.             dc.LineTo(designdata->drag_point.x, designdata->drag_point.y);
  858.             dc.LineTo(designdata->drag_point.x, designdata->tmp_point.y);
  859.             dc.LineTo(designdata->tmp_point.x,  designdata->tmp_point.y);
  860.  
  861.             dc.MoveTo(point.x,                  point.y);
  862.             dc.LineTo(point.x,                  designdata->drag_point.y);
  863.             dc.LineTo(designdata->drag_point.x, designdata->drag_point.y);
  864.             dc.LineTo(designdata->drag_point.x, point.y);
  865.             dc.LineTo(point.x,                  point.y);
  866.  
  867.             designdata->tmp_point = point;
  868.         }
  869.         break;
  870.     }
  871. }
  872.  
  873. void TWinDisplay::EvMouseMove (UINT modKeys, TPoint& point)
  874. {
  875.     TWindow::EvMouseMove(modKeys, point);
  876.  
  877.     // INSERT>> 追加コードはここに
  878.  
  879.     if (designdata->selectstatus == SelNone) {
  880.         if (designdata->select == NULL) {
  881.            DisplayCursorObject(modKeys, point);
  882.         }
  883.         return;
  884.     }
  885.  
  886.     Vector v;
  887.     if (type == SelXY) {
  888.         v.x =  double(point.x - designdata->drag_point.x);
  889.         v.y = -double(point.y - designdata->drag_point.y);
  890.         v.z = 0.0;
  891.     } else if (type == SelYZ) {
  892.         v.x = 0.0;
  893.         v.y=  double(point.x - designdata->drag_point.x);
  894.         v.z = -double(point.y - designdata->drag_point.y);
  895.     } else {
  896.         v.x =  double(point.x - designdata->drag_point.x);
  897.         v.y = 0.0;
  898.         v.z = -double(point.y - designdata->drag_point.y);
  899.     }
  900.  
  901.     if (designdata->selectstatus == SelMode && designdata->select != NULL) {
  902.         OpSelect(modKeys, point, v);
  903.     }
  904.     if (designdata->selectstatus == SelMode) {
  905.         OpSelectMove(modKeys, point, v);
  906.     }
  907.     if (designdata->selectstatus == SelMode) {
  908. //        designdata->selectstatus = SelNone;
  909.         designdata->selectstatus = SelCombined;
  910.         designdata->tmp_point = designdata->drag_point;
  911.     }
  912.     OpDrag(modKeys, point, v);
  913. }
  914.  
  915. void TWinDisplay::OpSelectObject(UINT /*modKeys*/, TPoint& point)
  916. {
  917.     const int maxSelObj=128;
  918.     const int maxSelDist=markersize*10;
  919.     Parts *sel[maxSelObj];
  920.     int dis[maxSelObj];
  921.     int d, i, count = 0;
  922.     Parts *p;
  923.     for (p = designdata->parts; p != NULL; p = p->next) {
  924.         if ((d = GetPositionDistance(p,point)) < maxSelDist) {
  925.             if (count < maxSelObj || dis[count-1] > d) {
  926.                 if (count < maxSelObj) {
  927.                     count++;
  928.                 }
  929.                 for (i = count-1; i > 0; --i) {
  930.                     if (dis[i-1] < d) {
  931.                         break;
  932.                     }
  933.                     dis[i] = dis[i-1];
  934.                     sel[i] = sel[i-1];
  935.                 }
  936.                 dis[i] = d;
  937.                 sel[i] = p;
  938.             }
  939.         }
  940.     }
  941.     if ((d = GetPositionDistance(designdata->camera, point)) < maxSelDist) {
  942.         if (count < maxSelObj || dis[count-1] > d) {
  943.             if (count < maxSelObj) {
  944.                 count++;
  945.             }
  946.             for (i = count-1; i > 0; --i) {
  947.                 if (dis[i-1] < d) {
  948.                     break;
  949.                 }
  950.                 dis[i] = dis[i-1];
  951.                 sel[i] = sel[i-1];
  952.             }
  953.             dis[i] = d;
  954.             sel[i] = designdata->camera;
  955.         }
  956.     }
  957.     Parts *selp = NULL;
  958.     if (count > 0) {
  959.          if (designdata->select == NULL) {
  960.             selp = sel[0];
  961.         } else {
  962.             for (i = 0; i < count-1; ++i) {
  963.                 if (sel[i] == designdata->select) {
  964.                     selp = sel[i+1];
  965.                     break;
  966.                 }
  967.             }
  968.             if (i == count-1) {
  969.                 selp = sel[0];
  970.             }
  971.         }
  972.     }
  973.  
  974.     if (selp != NULL && designdata->select != selp) {
  975.         designdata->SelectParts(selp);
  976.         designdata->Redraw();
  977.     }
  978.  
  979. #if 0
  980.     Parts *p, *selp = NULL, *first = NULL;
  981.     for (p = designdata->parts; p != NULL; p = p -> next) {
  982.         if (GetPositionDistance(p, point) < markersize*3) {
  983.             if (first == NULL) {
  984.                 first = p;
  985.             }
  986.             if (selp == designdata->select) {
  987.                 selp = p;
  988.                 break;
  989.             }
  990.             selp = p;
  991.         }
  992.     }
  993.     if (p == NULL) {
  994.         if (GetPositionDistance(designdata->camera, point) < markersize*3) {
  995.             if (first == NULL) {
  996.                 first = designdata->camera;
  997.             }
  998.             selp = designdata->camera;
  999.         }
  1000.     }
  1001.     if (designdata->select == NULL || selp == designdata->select) {
  1002.         selp = first;
  1003.     }
  1004.     if (selp != NULL && designdata->select != selp) {
  1005.         designdata->SelectParts(selp);
  1006.         designdata->Redraw();
  1007.     }
  1008. #endif
  1009. }
  1010.  
  1011.  
  1012. void TWinDisplay::EvLButtonUp (UINT modKeys, TPoint& point)
  1013. {
  1014.     TWindow::EvLButtonUp(modKeys, point);
  1015.  
  1016.     // INSERT>> 追加コードはここに
  1017.  
  1018.     ReleaseCapture();
  1019.     if (designdata->selectstatus == SelNone) {
  1020.         return;
  1021.     }
  1022.  
  1023.     Vector v;
  1024.     if (type == SelXY) {
  1025.         v.x =  double(point.x - designdata->drag_point.x);
  1026.         v.y = -double(point.y - designdata->drag_point.y);
  1027.         v.z = 0.0;
  1028.     } else if (type == SelYZ) {
  1029.         v.x = 0.0;
  1030.         v.y=  double(point.x - designdata->drag_point.x);
  1031.         v.z = -double(point.y - designdata->drag_point.y);
  1032.     } else {
  1033.         v.x =  double(point.x - designdata->drag_point.x);
  1034.         v.y = 0.0;
  1035.         v.z = -double(point.y - designdata->drag_point.y);
  1036.     }
  1037.     Vector tmpvec;
  1038.     switch (designdata->selectstatus & SelMode) {
  1039.     case SelMode:
  1040.         OpSelectObject(modKeys, point);
  1041.         break;
  1042.     case SelMove:
  1043.         if (modKeys & MK_SHIFT) {
  1044.             SelectOne(v);
  1045.         }
  1046.         tmpvec = designdata->select->position;
  1047.         designdata->select->position += (1.0/designdata->displayscale) * v;
  1048.         limit(designdata->select->position);
  1049.         if (((modKeys & MK_CONTROL) != 0) ^ (designdata->gridflag != FALSE)) {
  1050.             engrid(designdata->select->position, designdata->gridspacing);
  1051.             if (v.x == 0.0) designdata->select->position.x = tmpvec.x;
  1052.             if (v.y == 0.0) designdata->select->position.y = tmpvec.y;
  1053.             if (v.z == 0.0) designdata->select->position.z = tmpvec.z;
  1054.         }
  1055.         if (tmpvec != designdata->select->position) {
  1056.             if (designdata->select == designdata->camera) {
  1057.                 designdata->camera->SetTarget(designdata->camera->target);
  1058.                 designdata->CalcPoints(designdata->select);
  1059.                 designdata->CalcViewAll();
  1060.             } else {
  1061.                 designdata->CalcPoints(designdata->select);
  1062.             }
  1063.             if (designdata->select != designdata->camera) {
  1064.                 designdata->editflag++;
  1065.             }
  1066.             designdata->Redraw();
  1067.         }
  1068.         break;
  1069.     case SelTarget:
  1070.         if (modKeys & MK_SHIFT) {
  1071.             SelectOne(v);
  1072.         }
  1073.         tmpvec = designdata->camera->target + (1.0 / designdata->displayscale) * v;
  1074.         limit(tmpvec);
  1075.         if (((modKeys & MK_CONTROL) != 0) ^ (designdata->gridflag != FALSE)) {
  1076.             engrid(tmpvec, designdata->gridspacing);
  1077.             if (v.x == 0.0) tmpvec.x = designdata->camera->target.x;
  1078.             if (v.y == 0.0) tmpvec.y = designdata->camera->target.y;
  1079.             if (v.z == 0.0) tmpvec.z = designdata->camera->target.z;
  1080.         }
  1081.         if (tmpvec != designdata->camera->target) {
  1082.             designdata->camera->SetTarget(tmpvec);
  1083.             designdata->CalcPoints(designdata->camera);
  1084.             designdata->CalcViewAll();
  1085. //            designdata->editflag++;
  1086.             designdata->Redraw();
  1087.         }
  1088.         break;
  1089.     case SelRot: {
  1090.             double r;
  1091.             double px, py;
  1092.             Matrix nmat;
  1093.             r = designdata->drag_rx * (point.x - designdata->drag_point.x)
  1094.               + designdata->drag_ry * (point.y - designdata->drag_point.y);
  1095.             switch (designdata->selectstatus & SelXYZ) {
  1096.             case SelNone:
  1097.                 switch (type) {
  1098.                 case SelXY:    nmat = Matrix(1).rotz(r); break;
  1099.                 case SelYZ:    nmat = Matrix(1).rotx(r); break;
  1100.                 case SelZX:    nmat = Matrix(1).roty(r); break;
  1101.                 }
  1102.                 nmat = nmat * designdata->drag_rot;
  1103.                 break;
  1104.             case SelX: nmat = designdata->drag_rot.rotx(r); break;
  1105.             case SelY: nmat = designdata->drag_rot.roty(r); break;
  1106.             case SelZ: nmat = designdata->drag_rot.rotz(r); break;
  1107.             case SelXY:
  1108.                 px = designdata->drag_px[0] * (point.x - designdata->drag_point.x)
  1109.                    + designdata->drag_px[1] * (point.y - designdata->drag_point.y);
  1110.                 py = designdata->drag_py[0] * (point.x - designdata->drag_point.x)
  1111.                    + designdata->drag_py[1] * (point.y - designdata->drag_point.y);
  1112.                 if (-minimumdouble < px && px < minimumdouble
  1113.                  && -minimumdouble < py && py < minimumdouble) {
  1114.                     nmat = designdata->drag_rot;
  1115.                 } else {
  1116.                     nmat = designdata->drag_rot.rotz(atan2(py, px));
  1117.                 }
  1118.                 break;
  1119.             case SelYZ:
  1120.                 px = designdata->drag_px[0] * (point.x - designdata->drag_point.x)
  1121.                    + designdata->drag_px[1] * (point.y - designdata->drag_point.y);
  1122.                 py = designdata->drag_py[0] * (point.x - designdata->drag_point.x)
  1123.                    + designdata->drag_py[1] * (point.y - designdata->drag_point.y);
  1124.                 if (-minimumdouble < px && px < minimumdouble
  1125.                  && -minimumdouble < py && py < minimumdouble) {
  1126.                     nmat = designdata->drag_rot;
  1127.                 } else {
  1128.                     nmat = designdata->drag_rot.rotx(atan2(py, px));
  1129.                 }
  1130.                 break;
  1131.             case SelZX:
  1132.                 px = designdata->drag_px[0] * (point.x - designdata->drag_point.x)
  1133.                    + designdata->drag_px[1] * (point.y - designdata->drag_point.y);
  1134.                 py = designdata->drag_py[0] * (point.x - designdata->drag_point.x)
  1135.                    + designdata->drag_py[1] * (point.y - designdata->drag_point.y);
  1136.                 if (-minimumdouble < px && px < minimumdouble
  1137.                  && -minimumdouble < py && py < minimumdouble) {
  1138.                     nmat = designdata->drag_rot;
  1139.                 } else {
  1140.                     nmat = designdata->drag_rot.roty(atan2(py, px));
  1141.                 }
  1142.                 break;
  1143.             }
  1144.             Vector tmprot = designdata->select->rotation;
  1145.             designdata->select->SetRotationParameter(nmat);
  1146.             if (((modKeys & MK_CONTROL) != 0) ^ (designdata->gridflag != FALSE)) {
  1147.                 Vector tmpvec = rad(1.0) * designdata->select->rotation;
  1148.                 engrid(tmpvec, designdata->rotspacing);
  1149.                 designdata->select->rotation = deg(1.0) * tmpvec;
  1150.             }
  1151.             if (tmprot != designdata->select->rotation) {
  1152.                 designdata->CalcPoints(designdata->select);
  1153.                 designdata->editflag++;
  1154.                 designdata->Redraw();
  1155.             }
  1156.         }
  1157.         break;
  1158.     case SelScale: {
  1159.             double r;
  1160.             r = designdata->drag_rx * (point.x - designdata->drag_point.x)
  1161.               + designdata->drag_ry * (point.y - designdata->drag_point.y);
  1162.             Vector tmpvec = designdata->select->scale;
  1163.             if ((modKeys & MK_SHIFT) || designdata->select == designdata->combined) {
  1164.                 tmpvec *= r;
  1165.             } else {
  1166.                 if (designdata->selectstatus & SelX) tmpvec.x *= r;
  1167.                 if (designdata->selectstatus & SelY) tmpvec.y *= r;
  1168.                 if (designdata->selectstatus & SelZ) tmpvec.z *= r;
  1169.             }
  1170.             int redrawflag;
  1171.             redrawflag = designdata->select->scale != tmpvec;
  1172.             if (tmpvec.x >  10000.0) { tmpvec.x =  10000.0; redrawflag = TRUE; }
  1173.             if (tmpvec.y >  10000.0) { tmpvec.y =  10000.0; redrawflag = TRUE; }
  1174.             if (tmpvec.z >  10000.0) { tmpvec.z =  10000.0; redrawflag = TRUE; }
  1175.             if (tmpvec.x < -10000.0) { tmpvec.x = -10000.0; redrawflag = TRUE; }
  1176.             if (tmpvec.y < -10000.0) { tmpvec.y = -10000.0; redrawflag = TRUE; }
  1177.             if (tmpvec.z < -10000.0) { tmpvec.z = -10000.0; redrawflag = TRUE; }
  1178.             if (((modKeys & MK_CONTROL) != 0) ^ (designdata->gridflag != FALSE)) {
  1179.                 Vector ovec = tmpvec;
  1180.                 tmpvec *= scalespacingfactor;
  1181.                 engrid(tmpvec, designdata->scalespacing);
  1182.                 tmpvec *= (1.0/scalespacingfactor);
  1183.                 if ((modKeys & MK_SHIFT) == 0 && designdata->select != designdata->combined) {
  1184.                     if ((designdata->selectstatus & SelX)==0) tmpvec.x = ovec.x;
  1185.                     if ((designdata->selectstatus & SelY)==0) tmpvec.y = ovec.y;
  1186.                     if ((designdata->selectstatus & SelZ)==0) tmpvec.z = ovec.z;
  1187.                 }
  1188.             }
  1189.             if (tmpvec.x == 0.0 || tmpvec.y == 0.0 || tmpvec.z == 0.0) {
  1190.                 Matrix nmat = designdata->drag_move * designdata->drag_rot * designdata->drag_scale;
  1191.                 designdata->ShowCube(designdata->drag_mat, nmat);
  1192.                 designdata->Status->DisplayScale(designdata->select->scale);
  1193.             } else if (redrawflag) {
  1194.                 designdata->select->scale = tmpvec;
  1195.                 designdata->CalcPoints(designdata->select);
  1196.                 designdata->Redraw();
  1197.                 designdata->editflag++;
  1198.             }
  1199.         }
  1200.         break;
  1201.     case SelCombined:
  1202.         {
  1203.             TClientDC dc(*this);
  1204.             dc.SetROP2(R2_NOTXORPEN);
  1205.             dc.SelectObject(TPen(cBackGround));
  1206.             dc.MoveTo(point.x,                  point.y);
  1207.             dc.LineTo(point.x,                  designdata->drag_point.y);
  1208.             dc.LineTo(designdata->drag_point.x, designdata->drag_point.y);
  1209.             dc.LineTo(designdata->drag_point.x, point.y);
  1210.             dc.LineTo(point.x,                  point.y);
  1211.  
  1212.             int x1, x2, y1, y2;
  1213.             if (point.x < designdata->drag_point.x) {
  1214.                 x1 = point.x;
  1215.                 x2 = designdata->drag_point.x;
  1216.             } else {
  1217.                 x1 = designdata->drag_point.x;
  1218.                 x2 = point.x;
  1219.             }
  1220.             if (point.y < designdata->drag_point.y) {
  1221.                 y1 = point.y;
  1222.                 y2 = designdata->drag_point.y;
  1223.             } else {
  1224.                 y1 = designdata->drag_point.y;
  1225.                 y2 = point.y;
  1226.             }
  1227.             int oldnparts = designdata->combined->nparts;
  1228.             designdata->combined->DeleteAllParts();
  1229.             Matrix m = convmatrix * Matrix::m_move(designdata->displayoffset).scale(designdata->displayscale);
  1230.             int px, py;
  1231.             for (Parts *p = designdata->parts;p != NULL; p = p->next) {
  1232.                 Vector pos;
  1233.                 pos = m * p->position;
  1234.                 px = Attr.W/2 + pos.x;
  1235.                 py = Attr.H/2 - pos.y;
  1236.                 if (x1 <= px && px <= x2 && y1 <= py && py <= y2) {
  1237.                     designdata->combined->AddParts(p);
  1238.                     p->sel = TRUE;
  1239.                 } else {
  1240.                     p->sel = FALSE;
  1241.                 }
  1242.             }
  1243.             if (designdata->combined->nparts == 1) {
  1244.                 designdata->SelectParts(designdata->combined->parts[0]);
  1245.                 designdata->Redraw();
  1246.             } else if (designdata->combined->nparts > 0) {
  1247.                 designdata->combined->CalcSizeAll();
  1248.                 designdata->SelectParts(designdata->combined);
  1249.                 designdata->Redraw();
  1250.             } else {
  1251.                 designdata->combined->nparts = oldnparts;
  1252.             }
  1253.         }
  1254.         break;
  1255.  
  1256.     }
  1257.     designdata->selectstatus = SelNone;
  1258. }
  1259.  
  1260. void TWinDisplay::EvRButtonDown (UINT modKeys, TPoint& point)
  1261. {
  1262.     TWindow::EvRButtonDown(modKeys, point);
  1263.  
  1264.     // INSERT>> 追加コードはここに
  1265.  
  1266.     if (designdata->selectstatus != SelNone) {
  1267.         designdata->selectstatus = SelNone;
  1268.         designdata->Redraw();
  1269.     } else if (designdata->select != NULL) {
  1270.         designdata->SelectParts(NULL);
  1271.         designdata->Redraw();
  1272.     }
  1273.     ReleaseCapture();
  1274.  
  1275. }
  1276.  
  1277. void TWinDisplay::ShowGrid(TDC& dc)
  1278. {
  1279.     if (designdata->meshflag == FALSE) {
  1280.         return;
  1281.     }
  1282.     Vector v = convmatrix * designdata->displayoffset;
  1283.     double bx = - (1.0 / designdata->displayscale) * (v.x + Attr.W / 2);
  1284.     double by = - (1.0 / designdata->displayscale) * (v.y + Attr.H / 2);
  1285.     int cx = (1.0 / designdata->displayscale) * Attr.W / designdata->meshspacing+1;
  1286.     int cy = (1.0 / designdata->displayscale) * Attr.H / designdata->meshspacing+1;
  1287. //    TClientDC dc(*this);
  1288.     dc.SelectObject(TPen(cGrid));
  1289.     dc.SelectObject(TPen(cGrid,1,PS_DOT));
  1290.     dc.SetBkMode(TRANSPARENT);
  1291. //    dc.SelectObject(TBrush(cBackGround));
  1292.     int i;
  1293.  
  1294.     if (bx < 0) {
  1295.         bx = -((long)(-bx)/designdata->meshspacing) * designdata->meshspacing;
  1296.     } else {
  1297.         bx =  ((long)( bx)/designdata->meshspacing) * designdata->meshspacing;
  1298.     }
  1299.     for (i = 0; i < cx; ++i) {
  1300.         int x = bx * designdata->displayscale + v.x + Attr.W / 2;
  1301.         if (-designdata->meshspacing/2 < bx && bx < designdata->meshspacing/2) {
  1302.             dc.SelectObject(TPen(cGridZero));
  1303.             dc.MoveTo(x,0);
  1304.             dc.LineTo(x,Attr.H);
  1305.             dc.SelectObject(TPen(cGrid,1,PS_DOT));
  1306. //            dc.SelectObject(TPen(cGrid));
  1307.         } else {
  1308.             dc.MoveTo(x,0);
  1309.             dc.LineTo(x,Attr.H);
  1310.         }
  1311.         bx += designdata->meshspacing;
  1312.     }
  1313.     if (by < 0) {
  1314.         by = -((long)(-by)/designdata->meshspacing) * designdata->meshspacing;
  1315.     } else {
  1316.         by =  ((long)( by)/designdata->meshspacing) * designdata->meshspacing;
  1317.     }
  1318.     for (i = 0; i < cy; ++i) {
  1319.         int y = -by * designdata->displayscale - v.y + Attr.H / 2;
  1320.         if (-designdata->meshspacing/2 < by && by     < designdata->meshspacing/2) {
  1321.             dc.SelectObject(TPen(cGridZero));
  1322.             dc.MoveTo(0,y);
  1323.             dc.LineTo(Attr.W,y);
  1324.             dc.SelectObject(TPen(cGrid,1,PS_DOT));
  1325. //            dc.SelectObject(TPen(cGrid));
  1326.         } else {
  1327.             dc.MoveTo(0,y);
  1328.             dc.LineTo(Attr.W,y);
  1329.         }
  1330.         by += designdata->meshspacing;
  1331.     }
  1332.  
  1333. }
  1334.  
  1335. void TWinDisplay::Zoom(UINT /*modKeys*/, TPoint& point)
  1336. {
  1337.     Vector v;
  1338.     if (type == SelXY) {
  1339.         v.x =  double(point.x - Attr.W/2);
  1340.         v.y = -double(point.y - Attr.H/2);
  1341.         v.z = 0.0;
  1342.     } else if (type == SelYZ) {
  1343.         v.x = 0.0;
  1344.         v.y=  double(point.x - Attr.W/2);
  1345.         v.z = -double(point.y - Attr.H/2);
  1346.     } else {
  1347.         v.x =  double(point.x - Attr.W/2);
  1348.         v.y = 0.0;
  1349.         v.z = -double(point.y - Attr.H/2);
  1350.     }
  1351.     designdata->displayoffset -= v;
  1352.     designdata->displayscale *= 4;
  1353.     designdata->displayoffset = 4 * designdata->displayoffset;
  1354.     designdata->SetScrollLimit(TRUE);
  1355.  
  1356.     designdata->zoommode = ZoomNow;
  1357.     designdata->Redraw(SelXYZ | SelStat, TRUE);
  1358. }
  1359.  
  1360. void TWinDisplay::ShowObject(TDC& dc, Parts *p)
  1361. {
  1362.     Matrix m = designdata->GetMatrix(p);
  1363.  
  1364.     int i = 0;
  1365.     int begin, end = -1;
  1366.     int cx, cy;
  1367.     cx = Attr.W / 2;
  1368.     cy = Attr.H / 2;
  1369.  
  1370.     int combflag = (designdata->combined == designdata->select);
  1371.  
  1372.     if (p == designdata->select || (combflag && p->sel)) {
  1373.         dc.SelectObject(TPen(cWireSelect));
  1374.     } else if (p == designdata->camera) {
  1375.         if (designdata->select != NULL) {
  1376.             dc.SelectObject(TPen(cWireCameraNoSelect));
  1377.         } else {
  1378.             dc.SelectObject(TPen(cWireCamera));
  1379.         }
  1380.     } else {
  1381.         if (designdata->select != NULL) {
  1382.             dc.SelectObject(TPen(cWireNoSelect));
  1383.         } else {
  1384.             dc.SelectObject(TPen(cWireNormal));
  1385.         }
  1386.     }
  1387.  
  1388.     int *ppx, *ppy;
  1389.     switch(type) {
  1390.     case SelYZ:
  1391.         ppx = p->point_y;
  1392.         ppy = p->point_z;
  1393.         break;
  1394.     case SelZX:
  1395.         ppx = p->point_x;
  1396.         ppy = p->point_z;
  1397.         break;
  1398.     case SelXY:
  1399.         ppx = p->point_x;
  1400.         ppy = p->point_y;
  1401.         break;
  1402.     }
  1403.  
  1404.     for (; i < p->lines; ++i) {
  1405.         if ((begin = p->line_1[i]) != end) {
  1406.             dc.MoveTo(cx + ppx[begin], cy - ppy[begin]);
  1407.         }
  1408.         end = p->line_2[i];
  1409.         dc.LineTo(cx + ppx[end],   cy - ppy[end]);
  1410.     }
  1411.  
  1412.     if (designdata->select == NULL) {
  1413.         dc.SelectObject(TPen(cMarker));
  1414.         dc.SelectObject(TBrush(cMarker));
  1415.         switch(type) {
  1416.         case SelYZ:
  1417.             dc.Rectangle(cx+m.v[3].y-markersize, cy-m.v[3].z-markersize,
  1418.                          cx+m.v[3].y+markersize, cy-m.v[3].z+markersize);
  1419.             break;
  1420.         case SelZX:
  1421.             dc.Rectangle(cx+m.v[3].x-markersize, cy-m.v[3].z-markersize,
  1422.                          cx+m.v[3].x+markersize, cy-m.v[3].z+markersize);
  1423.             break;
  1424.         case SelXY:
  1425.             dc.Rectangle(cx+m.v[3].x-markersize, cy-m.v[3].y-markersize,
  1426.                          cx+m.v[3].x+markersize, cy-m.v[3].y+markersize);
  1427.             break;
  1428.         }
  1429.     }
  1430. }
  1431.  
  1432. void TWinDisplay::Redraw(void)
  1433. {
  1434. #if 0
  1435.     TClientDC cdc(*this);
  1436.     TMemoryDC dc(cdc);
  1437.     TBitmap bitmap(cdc, Attr.W, Attr.H);
  1438.     dc.SelectObject(bitmap);
  1439. #else
  1440.     TClientDC dc(*this);
  1441. #endif
  1442.  
  1443.     dc.SelectObject(TPen(cBackGround));
  1444.     dc.SelectObject(TBrush(cBackGround));
  1445.     dc.Rectangle(dc.GetClipBox());
  1446.     ShowGrid(dc);
  1447.     dc.SetBkColor(cBackGround);
  1448.     dc.SetTextColor(TColor::White);
  1449.     if (type == SelXY) {
  1450.         dc.TextOut(0,0,"上");
  1451.     } else if (type == SelZX) {
  1452.         dc.TextOut(0,0,"横");
  1453.     } else {
  1454.         dc.TextOut(0,0,"前");
  1455.     }
  1456.     for (Parts *p = designdata->parts; p != NULL; p = p->next) {
  1457.         if (p != designdata->select) {
  1458.             ShowObject(dc, p);
  1459.         }
  1460.     }
  1461.     if (designdata->camera != designdata->select) {
  1462.         ShowObject(dc, designdata->camera);
  1463.         if (designdata->select != NULL) {
  1464.             ShowObject(dc, designdata->select);
  1465.         }
  1466.     }
  1467. #if 0
  1468.     cdc.BitBlt(0,0,Attr.W, Attr.H, dc, 0, 0, SRCCOPY);
  1469. #endif
  1470. }
  1471.