home *** CD-ROM | disk | FTP | other *** search
/ 10,000 Great Games / 10,000 Great Games.iso / Product / 66 / data1.cab / Source_Files / Src / BlasterView.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-16  |  13.3 KB  |  670 lines
  1. #include "stdafx.h"
  2.  
  3. #include "NewObject.h"
  4.  
  5. cEditable *left_editable;
  6.  
  7. static cEditable *right_editable;
  8. static CPoint last_game_point, last_back_point;
  9. static int dragging;
  10.  
  11. IMPLEMENT_DYNCREATE(CBlasterView, CScrollView)
  12.  
  13. BEGIN_MESSAGE_MAP(CBlasterView, CScrollView)
  14.     //{{AFX_MSG_MAP(CBlasterView)
  15.     ON_WM_KEYDOWN()    
  16.     ON_WM_SETCURSOR()
  17.     ON_WM_ERASEBKGND()
  18.     ON_COMMAND(ID_NEW_OBJECT, OnNewObject)
  19.     ON_COMMAND(ID_SCROLL_UP, OnScrollUp)
  20.     ON_COMMAND(ID_SCROLL_DOWN, OnScrollDown)
  21.     ON_COMMAND(ID_PAGE_DOWN, OnPageDown)
  22.     ON_COMMAND(ID_PAGE_UP, OnPageUp)
  23.     ON_COMMAND(ID_SCROLL_END, OnScrollEnd)
  24.     ON_COMMAND(ID_SCROLL_HOME, OnScrollHome)
  25.     ON_WM_LBUTTONDOWN()
  26.     ON_WM_LBUTTONUP()
  27.     ON_WM_MOUSEMOVE()
  28.     ON_COMMAND(ID_DELETE, OnDelete)
  29.     ON_COMMAND(ID_EDIT_SNAPTOGRID, OnEditSnaptogrid)
  30.     ON_UPDATE_COMMAND_UI(ID_EDIT_SNAPTOGRID, OnUpdateEditSnaptogrid)
  31.     ON_COMMAND(ID_SCROLL_LEFT, OnScrollLeft)
  32.     ON_COMMAND(ID_SCROLL_RIGHT, OnScrollRight)
  33.     ON_WM_RBUTTONDOWN()
  34.     ON_COMMAND(ID_CONTEXT_0, OnContext0)
  35.     ON_COMMAND(ID_CONTEXT_1, OnContext1)
  36.     ON_COMMAND(ID_CONTEXT_2, OnContext2)
  37.     ON_COMMAND(ID_CONTEXT_3, OnContext3)
  38.     ON_COMMAND(ID_CONTEXT_4, OnContext4)
  39.     ON_COMMAND(ID_CONTEXT_5, OnContext5)
  40.     ON_COMMAND(ID_CONTEXT_6, OnContext6)
  41.     ON_UPDATE_COMMAND_UI(ID_DELETE, OnUpdateDelete)
  42.     ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateEditCopy)
  43.     ON_UPDATE_COMMAND_UI(ID_EDIT_CUT, OnUpdateEditCut)
  44.     ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE, OnUpdateEditPaste)
  45.     ON_WM_PAINT()        
  46.     ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
  47.     ON_COMMAND(ID_EDIT_CUT, OnEditCut)
  48.     ON_COMMAND(ID_EDIT_PASTE, OnEditPaste)
  49.     //}}AFX_MSG_MAP
  50. END_MESSAGE_MAP()
  51.  
  52. CBlasterView::CBlasterView()
  53. {    
  54. }
  55.  
  56. CBlasterView::~CBlasterView()
  57. {
  58. }
  59.  
  60. BOOL CBlasterView::PreCreateWindow(CREATESTRUCT& cs)
  61. {
  62.     return CScrollView::PreCreateWindow(cs);
  63. }
  64.  
  65. void CBlasterView::OnDraw(CDC* pDC)
  66. {    
  67.     write_frame();    
  68. }
  69.  
  70. #ifdef _DEBUG
  71. void CBlasterView::AssertValid() const
  72. {
  73.     CScrollView::AssertValid();
  74. }
  75.  
  76. void CBlasterView::Dump(CDumpContext& dc) const
  77. {
  78.     CScrollView::Dump(dc);
  79. }
  80.  
  81. CBlasterDoc* CBlasterView::GetDocument() 
  82. {
  83.     ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CBlasterDoc)));
  84.     return (CBlasterDoc*)m_pDocument;
  85. }
  86. #endif 
  87.  
  88. BOOL CBlasterView::Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext) 
  89. {
  90.     return CWnd::Create(lpszClassName, lpszWindowName, dwStyle, rect, pParentWnd, nID, pContext);
  91. }
  92.  
  93. void CBlasterView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  94. {
  95.     CScrollView::OnKeyDown(nChar, nRepCnt, nFlags);
  96. }
  97.  
  98. BOOL CBlasterView::DestroyWindow() 
  99. {
  100.     return CScrollView::DestroyWindow();
  101. }
  102.  
  103. BOOL CBlasterView::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  104. {
  105.     SetCursor(LoadCursor(0, IDC_ARROW));
  106.  
  107.     return TRUE;
  108. }
  109.  
  110. void CBlasterView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView) 
  111. {
  112.     if (bActivate)
  113.     {
  114.         if (!end_game)
  115.             cTimer::unpause();        
  116.     }
  117.     else
  118.     {
  119.         selectionbox_active = FALSE;
  120.  
  121.         ClipCursor(0);
  122.         
  123.         cTimer::pause();
  124.     }
  125.     
  126.     CScrollView::OnActivateView(bActivate, pActivateView, pDeactiveView);
  127. }
  128.  
  129. void CBlasterView::OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint) 
  130. {
  131.     // Setup scroll bars
  132.  
  133.     SetScrollSizes(MM_TEXT, CSize(SCREEN_X, LEVEL_SIZE), CSize(10, SCROLL_PAGE), CSize(10, SCROLL_STEP));    
  134.  
  135.     // Scroll to start of level
  136.  
  137.     ScrollTo(0, 0);
  138. }
  139.  
  140. BOOL CBlasterView::OnEraseBkgnd(CDC* pDC) 
  141. {
  142.     // Erase everything except the game area
  143.     
  144.     CBrush br(GetSysColor(COLOR_APPWORKSPACE)); 
  145.     
  146.     CRect rect;
  147.     
  148.     GetClientRect(rect);
  149.     
  150.     rect.left = SCREEN_X;
  151.     
  152.     if (!rect.IsRectEmpty())
  153.         pDC->FillRect(rect, &br);
  154.  
  155.     rect.left = 0;
  156.     rect.right = SCREEN_X;
  157.     rect.top = SCREEN_Y;
  158.     
  159.     if (!rect.IsRectEmpty())
  160.         pDC->FillRect(rect, &br);
  161.  
  162.     return TRUE;
  163. }
  164.  
  165. void CBlasterView::ScrollTo(int x, int y)
  166. {
  167.     // Check boundaries of x
  168.  
  169.     CRect r;
  170.     GetClientRect(&r);
  171.     
  172.     if (x + r.right - r.left > SCREEN_X)
  173.         x = SCREEN_X - r.right + r.left;
  174.  
  175.     if (x < 0)
  176.         x = 0;
  177.     
  178.     // Do scroll
  179.  
  180.     set_scroll_position(y);
  181.  
  182.     // Create new editables
  183.  
  184.     cEditable::make_editables();
  185.  
  186.     // Redraw our window
  187.  
  188.     Invalidate();
  189.  
  190.     // Update scroll bar
  191.  
  192.     ScrollToPosition(CPoint(x, LEVEL_SIZE - GAME_DY + 1 - game_surface->start));
  193.  
  194.     // Make sure OnMouseMove is called
  195.  
  196.     CPoint p;
  197.     GetCursorPos(&p);
  198.     SetCursorPos(p.x, p.y);    
  199. }
  200.  
  201. BOOL CBlasterView::OnScrollBy(CSize sizeScroll, BOOL bDoScroll) 
  202. {
  203.     ScrollTo(GetScrollPosition().x, LEVEL_SIZE - GAME_DY + 1 - GetScrollPosition().y);
  204.         
  205.     return CScrollView::OnScrollBy(sizeScroll, bDoScroll);
  206. }
  207.  
  208. void CBlasterView::OnScrollUp() 
  209. {
  210.     ScrollTo(GetScrollPosition().x, game_surface->start + SCROLL_STEP);    
  211. }
  212.  
  213. void CBlasterView::OnScrollDown() 
  214. {
  215.     ScrollTo(GetScrollPosition().x, game_surface->start - SCROLL_STEP);
  216. }
  217.  
  218. void CBlasterView::OnPageUp() 
  219. {
  220.     ScrollTo(GetScrollPosition().x, game_surface->start + SCROLL_PAGE);    
  221. }
  222.  
  223. void CBlasterView::OnPageDown() 
  224. {
  225.     ScrollTo(GetScrollPosition().x, game_surface->start - SCROLL_PAGE);    
  226. }
  227.  
  228. void CBlasterView::OnScrollHome() 
  229. {
  230.     if (!selectionbox_active && !cEditable::anything_selected())
  231.         ScrollTo(GetScrollPosition().x, 0);    
  232. }
  233.  
  234. void CBlasterView::OnScrollEnd() 
  235. {
  236.     if (!selectionbox_active && !cEditable::anything_selected())
  237.         ScrollTo(GetScrollPosition().x, LEVEL_SIZE);    
  238. }
  239.  
  240. void CBlasterView::OnScrollLeft() 
  241. {
  242.     ScrollTo(GetScrollPosition().x - SCROLL_STEP, game_surface->start);
  243. }
  244.  
  245. void CBlasterView::OnScrollRight() 
  246. {
  247.     ScrollTo(GetScrollPosition().x + SCROLL_STEP, game_surface->start);
  248. }
  249.  
  250. void CBlasterView::OnNewObject() 
  251. {
  252.     CNewObject n;
  253.     n.DoModal();    
  254. }
  255.  
  256. void CBlasterView::ClientToSurface(CPoint &p, cSurface *surface, CPoint &s)
  257. {
  258.     int x = GetScrollPosition().x;
  259.  
  260.     // Clip point
  261.  
  262.     if (p.x < GAME_X - x)
  263.         p.x = GAME_X - x;
  264.     else if (p.x >= GAME_X + GAME_DX - x)
  265.         p.x = GAME_X + GAME_DX - x - 1;
  266.  
  267.     if (p.y < 0)
  268.         p.y = 0;
  269.     else if (p.y >= SCREEN_Y)
  270.         p.y = SCREEN_Y - 1;
  271.  
  272.     // Translate point
  273.  
  274.     s.x = p.x - GAME_X - GetScrollPosition().x;
  275.     s.y = GAME_DY - 1 - p.y + surface->start;
  276. }
  277.  
  278. void CBlasterView::SurfaceToClient(CPoint &p, cSurface *surface, CPoint &s)
  279. {
  280.     // Translate point
  281.  
  282.     s.x = p.x + GAME_X - GetScrollPosition().x;
  283.     s.y = GAME_DY - 1 - p.y + surface->start;
  284.  
  285.     // Clip point
  286.  
  287.     if (s.x < 0)
  288.         s.x = 0;
  289.     else if (s.x >= SCREEN_X)
  290.         s.x = SCREEN_X - 1;
  291.  
  292.     if (s.y < 0)
  293.         s.y = 0;
  294.     else if (s.y >= SCREEN_Y)
  295.         s.y = SCREEN_Y - 1;
  296. }
  297.  
  298. void CBlasterView::OnLButtonDown(UINT nFlags, CPoint point) 
  299. {
  300.     selectionbox_active = FALSE;
  301.     dragging = FALSE;
  302.  
  303.     // Remember last point
  304.  
  305.     ClientToSurface(point, game_surface, last_game_point);
  306.     ClientToSurface(point, back_surface, last_back_point);
  307.  
  308.     // Search for editable on current mouse spot
  309.  
  310.     left_editable = cEditable::find(last_game_point.x, last_game_point.y);
  311.  
  312.     if (left_editable == 0)
  313.     {
  314.         // Not an editable, if not shift held then unselect all
  315.  
  316.         if (!(nFlags & MK_SHIFT))
  317.              cEditable::unselect_editables();
  318.  
  319.         // Start rectangle
  320.  
  321.         cEditable::set_rectangle(last_game_point.x, last_game_point.y);
  322.  
  323.         // Redraw our window
  324.  
  325.         Invalidate();
  326.     }
  327.     else if (!left_editable->selected)
  328.     {
  329.         // Current is not selected, if not shift held then unselect all
  330.  
  331.         if (!(nFlags & MK_SHIFT))
  332.             cEditable::unselect_editables();
  333.  
  334.         // Redraw our window
  335.  
  336.         Invalidate();
  337.     }
  338.  
  339.     // Clip mouse to window
  340.  
  341.     CRect r;
  342.     GetClientRect(&r);
  343.     ClientToScreen(&r);
  344.     ClipCursor(&r);
  345.  
  346.     // Call base class
  347.     
  348.     CScrollView::OnLButtonDown(nFlags, point);
  349. }
  350.  
  351. void CBlasterView::OnLButtonUp(UINT nFlags, CPoint point) 
  352. {
  353.     if (selectionbox_active)
  354.     {
  355.         // Translate selection box to selection
  356.  
  357.         cEditable::rectangle_to_selection();
  358.  
  359.         // Redraw our window
  360.  
  361.         Invalidate();
  362.     }
  363.  
  364.     else if (snap_to_grid && dragging)
  365.     {
  366.         // We were dragging and snap to grid is on
  367.  
  368.         cEditable::snap_editables_to_grid();
  369.         
  370.         // Redraw our window
  371.  
  372.         Invalidate();
  373.     }
  374.         
  375.     else if (left_editable != 0 && !dragging)
  376.     {
  377.         // Unselect all if we're not dragging and clicking in mid air
  378.  
  379.         if (!(nFlags & MK_SHIFT))
  380.             cEditable::unselect_editables();
  381.  
  382.         // Toggle selection for current editable
  383.  
  384.         left_editable->selected = !left_editable->selected;
  385.  
  386.         // Redraw our window
  387.  
  388.         Invalidate();
  389.     }
  390.  
  391.     // Not dragging anymore
  392.  
  393.     dragging = FALSE;
  394.  
  395.     // Release clip
  396.  
  397.     ClipCursor(0);
  398.  
  399.     // Call base class
  400.  
  401.     CScrollView::OnLButtonUp(nFlags, point);
  402. }
  403.  
  404. void CBlasterView::OnRButtonDown(UINT nFlags, CPoint point) 
  405. {
  406.     CPoint p;
  407.     CMenu popup;
  408.  
  409.     // Unselect all editables
  410.  
  411.     cEditable::unselect_editables();
  412.  
  413.     // Redraw our window
  414.  
  415.     Invalidate();
  416.  
  417.     // Get editable
  418.  
  419.     ClientToSurface(point, game_surface, p);    
  420.     right_editable = cEditable::find(p.x, p.y);
  421.  
  422.     // Check if anything was found
  423.  
  424.     if (right_editable == 0)
  425.         return;
  426.     
  427.     // Select this editable
  428.  
  429.     right_editable->selected = TRUE;
  430.  
  431.     // Create popup    
  432.  
  433.     popup.CreatePopupMenu();
  434.     right_editable->create_context_menu(&popup);
  435.         
  436.     // Show pop-up menu
  437.  
  438.     GetCursorPos(&p);    
  439.     popup.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, p.x, p.y, this);
  440.  
  441.     // Call base class
  442.  
  443.     CScrollView::OnRButtonDown(nFlags, point);
  444. }
  445.  
  446. void CBlasterView::OnMouseMove(UINT nFlags, CPoint point) 
  447. {        
  448.     CPoint p_back, p_game;
  449.     
  450.     ClientToSurface(point, back_surface, p_back),
  451.     ClientToSurface(point, game_surface, p_game);
  452.  
  453.     if (nFlags & MK_LBUTTON && p_game != last_game_point)
  454.     {            
  455.         if (selectionbox_active)
  456.         {
  457.             // Update rectangle edge
  458.  
  459.             cEditable::set_edge_rectangle(p_game.x, p_game.y);
  460.  
  461.             // Move mouse cursor
  462.  
  463.             CPoint m;
  464.             SurfaceToClient(p_game, game_surface, m);
  465.             ClientToScreen(&m);
  466.             SetCursorPos(m.x, m.y);        
  467.             
  468.             // Set last point
  469.  
  470.             last_game_point = p_game;
  471.             last_back_point = p_back;
  472.  
  473.             // Redraw our window
  474.  
  475.             Invalidate();
  476.         }
  477.         
  478.         else if (left_editable != 0)
  479.         {        
  480.             if (dragging)
  481.             {
  482.                 // Select editable
  483.  
  484.                 left_editable->selected = TRUE;
  485.                 
  486.                 // Drag editables
  487.  
  488.                 cEditable::drag_editables(p_back.x - last_back_point.x, p_back.y - last_back_point.y, p_game.x - last_game_point.x, p_game.y - last_game_point.y);
  489.                         
  490.                 // Move mouse cursor to the editable
  491.  
  492.                 CPoint m;
  493.                 SurfaceToClient(CPoint(left_editable->x, left_editable->y), left_editable->surface, m);            
  494.                 ClientToScreen(&m);
  495.                 SetCursorPos(m.x, m.y);        
  496.                 
  497.                 // Set last point
  498.  
  499.                 last_back_point.x = left_editable->x;
  500.                 last_back_point.y = left_editable->y - left_editable->surface->start + back_surface->start;
  501.                 
  502.                 last_game_point.x = left_editable->x;
  503.                 last_game_point.y = left_editable->y - left_editable->surface->start + game_surface->start;
  504.  
  505.                 // Document dirty
  506.  
  507.                 GetDocument()->SetModifiedFlag();
  508.  
  509.                 // Redraw our window
  510.  
  511.                 Invalidate();
  512.             }
  513.             else if (d_square(p_game.x - last_game_point.x, p_game.y - last_game_point.y) > 25)
  514.             {
  515.                 // Start dragging
  516.  
  517.                 dragging = TRUE;
  518.  
  519.                 // Set last_point
  520.                 
  521.                 last_game_point = p_game;            
  522.                 last_back_point = p_back;
  523.             }
  524.         }        
  525.     }
  526.  
  527.     // Call base class
  528.  
  529.     CScrollView::OnMouseMove(nFlags, point);
  530. }
  531.  
  532. void CBlasterView::OnEditCopy() 
  533. {
  534.     save_level(clipboard_level, TRUE);
  535. }
  536.  
  537. void CBlasterView::OnUpdateEditCopy(CCmdUI* pCmdUI) 
  538. {
  539.     pCmdUI->Enable(cEditable::anything_selected());    
  540. }
  541.  
  542. void CBlasterView::OnEditCut() 
  543. {
  544.     save_level(clipboard_level, TRUE);
  545.  
  546.     cEditable::delete_selected_editables();
  547.  
  548.     GetDocument()->SetModifiedFlag();
  549.  
  550.     Invalidate();
  551. }
  552.  
  553. void CBlasterView::OnUpdateEditCut(CCmdUI* pCmdUI) 
  554. {
  555.     pCmdUI->Enable(cEditable::anything_selected());
  556. }
  557.  
  558. void CBlasterView::OnEditPaste() 
  559. {
  560.     // Unselect everything
  561.  
  562.     cEditable::unselect_editables();
  563.  
  564.     // Load the clipboard level
  565.  
  566.     load_level(clipboard_level, TRUE);
  567.  
  568.     // Document is dirty
  569.  
  570.     GetDocument()->SetModifiedFlag();
  571.  
  572.     // Rewrite everything
  573.  
  574.     cSurface::all_surfaces_dirty();
  575.  
  576.     Invalidate();    
  577. }
  578.  
  579. void CBlasterView::OnUpdateEditPaste(CCmdUI* pCmdUI) 
  580. {
  581.     pCmdUI->Enable(file_exists(clipboard_level));
  582. }
  583.  
  584. void CBlasterView::OnDelete() 
  585. {
  586.     cEditable::delete_selected_editables();
  587.  
  588.     GetDocument()->SetModifiedFlag();
  589.  
  590.     Invalidate();
  591. }
  592.  
  593. void CBlasterView::OnUpdateDelete(CCmdUI* pCmdUI) 
  594. {
  595.     pCmdUI->Enable(cEditable::anything_selected());
  596. }
  597.  
  598. void CBlasterView::OnEditSnaptogrid() 
  599. {
  600.     snap_to_grid = !snap_to_grid;
  601. }
  602.  
  603. void CBlasterView::OnUpdateEditSnaptogrid(CCmdUI* pCmdUI) 
  604. {
  605.     pCmdUI->SetCheck(snap_to_grid);    
  606. }
  607.  
  608. void CBlasterView::OnContext0() 
  609. {
  610.     right_editable->execute_context_menu(0);    
  611.  
  612.     GetDocument()->SetModifiedFlag();
  613.  
  614.     Invalidate();
  615. }
  616.  
  617. void CBlasterView::OnContext1() 
  618. {
  619.     right_editable->execute_context_menu(1);    
  620.  
  621.     GetDocument()->SetModifiedFlag();
  622.  
  623.     Invalidate();
  624. }
  625.  
  626. void CBlasterView::OnContext2() 
  627. {
  628.     right_editable->execute_context_menu(2);
  629.  
  630.     GetDocument()->SetModifiedFlag();
  631.  
  632.     Invalidate();
  633. }
  634.  
  635. void CBlasterView::OnContext3() 
  636. {
  637.     right_editable->execute_context_menu(3);        
  638.  
  639.     GetDocument()->SetModifiedFlag();
  640.  
  641.     Invalidate();
  642. }
  643.  
  644. void CBlasterView::OnContext4() 
  645. {
  646.     right_editable->execute_context_menu(4);    
  647.  
  648.     GetDocument()->SetModifiedFlag();
  649.  
  650.     Invalidate();
  651. }
  652.  
  653. void CBlasterView::OnContext5() 
  654. {
  655.     right_editable->execute_context_menu(5);    
  656.  
  657.     GetDocument()->SetModifiedFlag();
  658.  
  659.     Invalidate();
  660. }
  661.  
  662. void CBlasterView::OnContext6() 
  663. {
  664.     right_editable->execute_context_menu(6);    
  665.  
  666.     GetDocument()->SetModifiedFlag();
  667.  
  668.     Invalidate();
  669. }
  670.