home *** CD-ROM | disk | FTP | other *** search
/ Point Programming 1 / PPROG1.ISO / c / fli106c / examples / object.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-25  |  35.7 KB  |  1,418 lines
  1. //
  2. // The Fusion Library Interface for DOS
  3. // Version 1.02
  4. // Copyright (C) 1990, 1991
  5. // Software Dimensions
  6. //
  7. // Dialog Development System
  8. //
  9.  
  10. #include "fliwin.h"
  11. #include "colors.h"
  12. #include "dds.h"
  13.  
  14. #include <stdio.h>
  15. #include <alloc.h>
  16. #include <mem.h>
  17. #include <string.h>
  18.  
  19. //-------------------------------------------------------------------------
  20. //
  21. // Place an object on the dialog
  22. //
  23. //-------------------------------------------------------------------------
  24.  
  25. void DialogWindow::PlaceObject(int Object)
  26. {
  27.   RemoveTheMenus();
  28.  
  29.   Pieces=(PieceHandler **)realloc(Pieces,++NumberPieces*sizeof(char *));
  30.  
  31.   switch (Object)
  32.   {
  33.     case PieceHandler::Box:
  34.       Pieces[NumberPieces-1]=new Box(&Blaze,CursorX,CursorY,2,2,CurrentColor);
  35.       break;
  36.  
  37.     case PieceHandler::FilledBox:
  38.       Pieces[NumberPieces-1]=new FilledBox(&Blaze,CursorX,CursorY,2,2,CurrentColor);
  39.       break;
  40.  
  41.     case PieceHandler::HorizontalLine:
  42.       Pieces[NumberPieces-1]=new HorizontalLine(&Blaze,CursorX,CursorY,1,1,CurrentColor);
  43.       break;
  44.  
  45.     case PieceHandler::VerticalLine:
  46.       Pieces[NumberPieces-1]=new VerticalLine(&Blaze,CursorX,CursorY,1,1,CurrentColor);
  47.       break;
  48.  
  49.     case PieceHandler::Shadow:
  50.       Pieces[NumberPieces-1]=new Shadow(&Blaze,CursorX,CursorY,1,1);
  51.       break;
  52.  
  53.     case PieceHandler::EraseArea:
  54.       Pieces[NumberPieces-1]=new EraseArea(&Blaze,CursorX,CursorY,1,1,CurrentColor);
  55.       break;
  56.  
  57.     case PieceHandler::ColorizeArea:
  58.       Pieces[NumberPieces-1]=new ColorizeArea(&Blaze,CursorX,CursorY,1,1,CurrentColor);
  59.       break;
  60.   }
  61.  
  62.   MouseHide();
  63.  
  64.   PieceHandler &Piece=*Pieces[NumberPieces-1];
  65.  
  66.   Piece.DrawFigure();
  67.   Blaze.HelpLine(0,"Use the keyboard or mouse to size the object (Esc aborts)");
  68.   MouseShow();
  69.  
  70.   // Size the object
  71.  
  72.   Event EventHandler;
  73.  
  74.   MousePosition(X+Piece.X+Piece.Width,Y+Piece.Y+Piece.Height);
  75.   MouseLocate();
  76.  
  77.   int MouseX=MouseHorizontal;
  78.   int MouseY=MouseVertical;
  79.  
  80.   for (;;)
  81.   {
  82.     switch (EventHandler.GetEvent())
  83.     {
  84.       case kbUp:
  85.         Piece.Size(0,-1);
  86.         VirtualizedInterior();
  87.         break;
  88.  
  89.       case kbDown:
  90.         Piece.Size(0,1);
  91.         if (Piece.Y+Piece.Height>Blaze.WhatWinHeight()-1)
  92.           Piece.Size(0,-((Piece.Y+Piece.Height)-Blaze.WhatWinHeight()));
  93.         VirtualizedInterior();
  94.         break;
  95.  
  96.       case kbLeft:
  97.         Piece.Size(-1,0);
  98.         VirtualizedInterior();
  99.         break;
  100.  
  101.       case kbRight:
  102.         Piece.Size(1,0);
  103.         if (Piece.X+Piece.Width>Blaze.WhatWinWidth()-1)
  104.           Piece.Size(-((Piece.X+Piece.Width)-Blaze.WhatWinWidth()),0);
  105.         VirtualizedInterior();
  106.         break;
  107.  
  108.       case MousedEvent:
  109.         if (MouseEvent&MouseMoved)
  110.         {
  111.           int NewX=MouseHorizontal-MouseX;
  112.           int NewY=MouseVertical-MouseY;
  113.           MouseX=MouseHorizontal;
  114.           MouseY=MouseVertical;
  115.           Piece.Size(NewX,NewY);
  116.  
  117.           if (Piece.X+Piece.Width>Blaze.WhatWinWidth()-1)
  118.             Piece.Size(-((Piece.X+Piece.Width)-Blaze.WhatWinWidth()),0);
  119.           if (Piece.Y+Piece.Height>Blaze.WhatWinHeight()-1)
  120.             Piece.Size(0,-((Piece.Y+Piece.Height)-Blaze.WhatWinHeight()));
  121.  
  122.           if (MouseX!=X+Piece.X+Piece.Width || MouseY!=Y+Piece.Y+Piece.Height)
  123.           {
  124.             MousePosition(X+Piece.X+Piece.Width,Y+Piece.Y+Piece.Height);
  125.             MouseLocate();
  126.             MouseX=MouseHorizontal;
  127.             MouseY=MouseVertical;
  128.           }
  129.  
  130.           VirtualizedInterior();
  131.         }
  132.         if (MouseEvent&MouseLeftButtonRelease)
  133.           return;
  134.         break;
  135.  
  136.       case kbCr:
  137.         return;
  138.  
  139.       case kbEsc:
  140.         delete Pieces[NumberPieces-1];
  141.         NumberPieces--;
  142.         VirtualizedInterior();
  143.         return;
  144.     }
  145.   }
  146. }
  147.  
  148. //-------------------------------------------------------------------------
  149. //
  150. // Move an object around on the dialog
  151. //
  152. //-------------------------------------------------------------------------
  153.  
  154. int DialogWindow::MoveObject(int Moused,int PlaceObject)
  155. {
  156.   if (NumberPieces)
  157.   {
  158.     // Give elements priority for movement
  159.  
  160.     for (int i=NumberPieces-1;i>=0;i--)
  161.     {
  162.       PieceHandler &Piece=*Pieces[i];
  163.  
  164.       int PromptWidth=0;
  165.  
  166.       if (Piece.Prompter && *Piece.Prompter)
  167.       {
  168.         PromptWidth=strlen(Piece.Prompter)-(strchr(Piece.Prompter,'~')?1:0);
  169.       }
  170.  
  171.       if (CursorX>=Piece.X &&
  172.         CursorY>=Piece.Y &&
  173.         CursorX<Piece.X+Piece.Width &&
  174.         CursorY<Piece.Y+Piece.Height &&
  175.         Piece.LayOut>PieceHandler::__DUMMY__ && Piece.LayOut<PieceHandler::__DUMMY2__)
  176.         goto JumpIn;
  177.  
  178.       if (PromptWidth && CursorX>=Piece.PromptX &&
  179.         CursorY>=Piece.PromptY &&
  180.         CursorX<Piece.PromptX+PromptWidth &&
  181.         CursorY==Piece.PromptY &&
  182.         Piece.LayOut>PieceHandler::__DUMMY__ && Piece.LayOut<PieceHandler::__DUMMY2__)
  183.       {
  184.         PlacePrompter(Piece);
  185.         return 1;
  186.       }
  187.     }
  188.  
  189.     // If no elements under cursor, jump to remainer of objects in queue
  190.  
  191.     for (i=NumberPieces-1;i>=0;i--)
  192.     {
  193.  
  194. JumpIn:
  195.  
  196.       PieceHandler &Piece=*Pieces[i];
  197.  
  198.       if (CursorX>=Piece.X && CursorY>=Piece.Y &&
  199.         CursorX<Piece.X+Piece.Width && CursorY<Piece.Y+Piece.Height)
  200.       {
  201.         if (Moused && CursorY==Piece.Y+Piece.Height-1 &&
  202.           CursorX==Piece.X+Piece.Width-1 && Piece.LayOut<PieceHandler::__DUMMY__)
  203.         {
  204.           SizeObject(Moused);
  205.           return 1;
  206.         }
  207.  
  208.         RemoveTheMenus();
  209.  
  210.         Blaze.HelpLine(0,
  211.           (!PlaceObject)?"Use the keyboard or mouse to move the object (Esc aborts)":
  212.           "Use the keyboard or mouse to place the copied object (Esc aborts)");
  213.  
  214.         MousePosition(X+Piece.X+1,Y+Piece.Y+1);
  215.         MouseLocate();
  216.  
  217.         Event EventHandler;
  218.  
  219.         int SaveX=Piece.X;
  220.         int SaveY=Piece.Y;
  221.         int MouseX=MouseHorizontal;
  222.         int MouseY=MouseVertical;
  223.  
  224.         for (;;)
  225.         {
  226.           switch (EventHandler.GetEvent())
  227.           {
  228.             case kbUp:
  229.               if (!Piece.Y)
  230.                 continue;
  231.               Piece.Y--;
  232.               VirtualizedInterior();
  233.               break;
  234.  
  235.             case kbDown:
  236.               if (Piece.Y==Blaze.WhatWinHeight()-1)
  237.                 break;
  238.               Piece.Y++;
  239.               VirtualizedInterior();
  240.               break;
  241.  
  242.             case kbLeft:
  243.               if (!Piece.X)
  244.                 continue;
  245.               Piece.X--;
  246.               VirtualizedInterior();
  247.               break;
  248.  
  249.             case kbRight:
  250.               if (Piece.X==Blaze.WhatWinWidth()-1)
  251.                 break;
  252.               Piece.X++;
  253.               VirtualizedInterior();
  254.               break;
  255.  
  256.             case MousedEvent:
  257.               if (MouseEvent&MouseMoved)
  258.               {
  259.                 int NewX=MouseHorizontal-MouseX;
  260.                 int NewY=MouseVertical-MouseY;
  261.                 Piece.X+=NewX;
  262.                 Piece.Y+=NewY;
  263.                 MouseX=MouseHorizontal;
  264.                 MouseY=MouseVertical;
  265.  
  266.                 if (Piece.X<0)
  267.                   Piece.X=0;
  268.                 if (Piece.Y<0)
  269.                   Piece.Y=0;
  270.  
  271.                 if (Piece.X>Blaze.WhatWinWidth()-1)
  272.                   Piece.X=Blaze.WhatWinWidth()-1;
  273.                 if (Piece.Y>Blaze.WhatWinHeight()-1)
  274.                   Piece.Y=Blaze.WhatWinHeight()-1;
  275.  
  276.                 if (MouseX<X+1 || MouseX>=X+Width-1 ||
  277.                  MouseY<Y+1 || MouseY>=Y+Height-1)
  278.                 {
  279.                   MousePosition(X+Piece.X+1,Y+Piece.Y+1);
  280.                   MouseLocate();
  281.                   MouseX=MouseHorizontal;
  282.                   MouseY=MouseVertical;
  283.                 }
  284.  
  285.                 VirtualizedInterior();
  286.               }
  287.               if (MouseEvent&MouseLeftButtonRelease)
  288.                 return 1;
  289.               break;
  290.  
  291.             case kbCr:
  292.               return 1;
  293.  
  294.             case kbEsc:
  295.               Piece.X=SaveX;
  296.               Piece.Y=SaveY;
  297.               VirtualizedInterior();
  298.               return 0;
  299.           }
  300.         }
  301.       }
  302.     }
  303.   }
  304.  
  305.   if (Moused)
  306.     return 0;
  307.  
  308.   InfoBox NothingFound;
  309.  
  310.   NothingFound
  311.     + "Sorry, there is nothing below"
  312.     + "the cursor that can be moved.";
  313.  
  314.   NothingFound.Title("Nothing to Move");
  315.   NothingFound.UseInfoBox();
  316.  
  317.   return 0;
  318. }
  319.  
  320. //-------------------------------------------------------------------------
  321. //
  322. // Change the color of an object on the dialog
  323. //
  324. //-------------------------------------------------------------------------
  325.  
  326. void DialogWindow::ColorObject()
  327. {
  328.   if (NumberPieces)
  329.   {
  330.     for (int i=NumberPieces-1;i>=0;i--)
  331.     {
  332.       PieceHandler &Piece=*Pieces[i];
  333.  
  334.       if (CursorX>=Piece.X && CursorY>=Piece.Y &&
  335.         CursorX<Piece.X+Piece.Width && CursorY<Piece.Y+Piece.Width)
  336.       {
  337.         RemoveTheMenus();
  338.  
  339.         Piece.Color=CurrentColor;
  340.  
  341.         VirtualizedInterior();
  342.  
  343.         return;
  344.       }
  345.     }
  346.   }
  347.  
  348.   InfoBox NothingFound;
  349.  
  350.   NothingFound
  351.     + "Sorry, there is nothing below"
  352.     + "the cursor that can be colored.";
  353.  
  354.   NothingFound.Title("Nothing to Color");
  355.   NothingFound.UseInfoBox();
  356. }
  357.  
  358. //-------------------------------------------------------------------------
  359. //
  360. // Change the size of an object on the dialog
  361. //
  362. //-------------------------------------------------------------------------
  363.  
  364. void DialogWindow::SizeObject(int Moused)
  365. {
  366.   if (NumberPieces)
  367.   {
  368.     // Give elements priority for editation
  369.  
  370.     for (int i=NumberPieces-1;i>=0;i--)
  371.     {
  372.       PieceHandler &Piece=*Pieces[i];
  373.  
  374.       int PromptWidth=0;
  375.  
  376.       if (Piece.Prompter && *Piece.Prompter)
  377.       {
  378.         PromptWidth=strlen(Piece.Prompter)-(strchr(Piece.Prompter,'~')?1:0);
  379.       }
  380.  
  381.       if ((CursorX>=Piece.X &&
  382.         CursorY>=Piece.Y &&
  383.         CursorX<Piece.X+Piece.Width &&
  384.         CursorY<Piece.Y+Piece.Height &&
  385.         Piece.LayOut>PieceHandler::__DUMMY__) ||
  386.         (PromptWidth && CursorX>=Piece.PromptX &&
  387.         CursorY>=Piece.PromptY &&
  388.         CursorX<Piece.PromptX+PromptWidth &&
  389.         CursorY==Piece.PromptY &&
  390.         Piece.LayOut>PieceHandler::__DUMMY__))
  391.       {
  392.         EditElement(Piece);
  393.         return;
  394.       }
  395.     }
  396.  
  397.     for (i=NumberPieces-1;i>=0;i--)
  398.     {
  399.       PieceHandler &Piece=*Pieces[i];
  400.  
  401.       if ((Moused && CursorY==Piece.Y+Piece.Height-1 && CursorX==Piece.X+Piece.Width-1)
  402.         || (!Moused && (CursorX>=Piece.X && CursorY>=Piece.Y &&
  403.            CursorX<Piece.X+Piece.Width && CursorY<Piece.Y+Piece.Height)))
  404.       {
  405.         RemoveTheMenus();
  406.  
  407.         Blaze.HelpLine(0,"Use the keyboard or mouse to size the object (Esc aborts)");
  408.         MouseLocate();
  409.  
  410.         Event EventHandler;
  411.  
  412.         int SaveWidth=Piece.Width;
  413.         int SaveHeight=Piece.Height;
  414.         int MouseX=MouseHorizontal;
  415.         int MouseY=MouseVertical;
  416.  
  417.         for (;;)
  418.         {
  419.           switch (EventHandler.GetEvent())
  420.           {
  421.             case kbUp:
  422.               Piece.Size(0,-1);
  423.               VirtualizedInterior();
  424.               break;
  425.  
  426.             case kbDown:
  427.               Piece.Size(0,1);
  428.               if (Piece.Y+Piece.Height>Blaze.WhatWinHeight()-1)
  429.                 Piece.Size(0,-((Piece.Y+Piece.Height)-Blaze.WhatWinHeight()));
  430.               VirtualizedInterior();
  431.               break;
  432.  
  433.             case kbLeft:
  434.               Piece.Size(-1,0);
  435.               VirtualizedInterior();
  436.               break;
  437.  
  438.             case kbRight:
  439.               Piece.Size(1,0);
  440.               if (Piece.X+Piece.Width>Blaze.WhatWinWidth()-1)
  441.                 Piece.Size(-((Piece.X+Piece.Width)-Blaze.WhatWinWidth()),0);
  442.               VirtualizedInterior();
  443.               break;
  444.  
  445.             case MousedEvent:
  446.               if (MouseEvent&MouseMoved)
  447.               {
  448.                 int NewX=MouseHorizontal-MouseX;
  449.                 int NewY=MouseVertical-MouseY;
  450.                 MouseX=MouseHorizontal;
  451.                 MouseY=MouseVertical;
  452.                 Piece.Size(NewX,NewY);
  453.  
  454.                 if (Piece.X+Piece.Width>Blaze.WhatWinWidth()-1)
  455.                   Piece.Size(-((Piece.X+Piece.Width)-Blaze.WhatWinWidth()),0);
  456.                 if (Piece.Y+Piece.Height>Blaze.WhatWinHeight()-1)
  457.                   Piece.Size(0,-((Piece.Y+Piece.Height)-Blaze.WhatWinHeight()));
  458.  
  459.                 if (MouseX!=X+Piece.X+Piece.Width || MouseY!=Y+Piece.Y+Piece.Height)
  460.                 {
  461.                   MousePosition(X+Piece.X+Piece.Width,Y+Piece.Y+Piece.Height);
  462.                   MouseLocate();
  463.                   MouseX=MouseHorizontal;
  464.                   MouseY=MouseVertical;
  465.                 }
  466.  
  467.                 VirtualizedInterior();
  468.               }
  469.               if (MouseEvent&MouseLeftButtonRelease)
  470.                 return;
  471.               break;
  472.  
  473.             case kbCr:
  474.               return;
  475.  
  476.             case kbEsc:
  477.               Piece.Width=SaveWidth;
  478.               Piece.Height=SaveHeight;
  479.               VirtualizedInterior();
  480.               return;
  481.           }
  482.         }
  483.       }
  484.     }
  485.   }
  486.  
  487.   if (Moused)
  488.     return;
  489.  
  490.   InfoBox NothingFound;
  491.  
  492.   NothingFound
  493.     + "Sorry, there is nothing below"
  494.     + "the cursor that can be sized.";
  495.  
  496.   NothingFound.Title("Nothing to Size");
  497.   NothingFound.UseInfoBox();
  498. }
  499.  
  500. //-------------------------------------------------------------------------
  501. //
  502. // Bring an object to the front of the dialog
  503. //
  504. //-------------------------------------------------------------------------
  505.  
  506. void DialogWindow::BringFront()
  507. {
  508.   if (NumberPieces>1)
  509.   {
  510.     for (int i=NumberPieces-1;i>=0;i--)
  511.     {
  512.       PieceHandler &Piece=*Pieces[i];
  513.  
  514.       if (CursorX>=Piece.X && CursorY>=Piece.Y &&
  515.           CursorX<Piece.X+Piece.Width && CursorY<Piece.Y+Piece.Height &&
  516.           Piece.LayOut<PieceHandler::__DUMMY__)
  517.       {
  518.         RemoveTheMenus();
  519.  
  520.         if (i==NumberPieces-1)
  521.            return;
  522.  
  523.         PieceHandler *Hold=Pieces[i];
  524.  
  525.         movmem(&Pieces[i+1],&Pieces[i],(NumberPieces-i-1)*sizeof(PieceHandler *));
  526.  
  527.         Pieces[NumberPieces-1]=Hold;
  528.  
  529.         VirtualizedInterior();
  530.  
  531.         return;
  532.       }
  533.     }
  534.   }
  535.  
  536.   InfoBox NothingFound;
  537.  
  538.   NothingFound
  539.     + "Sorry, there isn\'t a drawn"
  540.     + "object below the cursor that"
  541.     + "can be pulled forward.";
  542.  
  543.   NothingFound.Title("Nothing to Pull");
  544.   NothingFound.UseInfoBox();
  545. }
  546.  
  547. //-------------------------------------------------------------------------
  548. //
  549. // Bring an object to the back of the dialog
  550. //
  551. //-------------------------------------------------------------------------
  552.  
  553. void DialogWindow::PushBack()
  554. {
  555.   if (NumberPieces>1)
  556.   {
  557.     for (int i=NumberPieces-1;i>=0;i--)
  558.     {
  559.       PieceHandler &Piece=*Pieces[i];
  560.  
  561.       if (CursorX>=Piece.X && CursorY>=Piece.Y &&
  562.           CursorX<Piece.X+Piece.Width && CursorY<Piece.Y+Piece.Height &&
  563.           Piece.LayOut<PieceHandler::__DUMMY__)
  564.       {
  565.         RemoveTheMenus();
  566.  
  567.         if (!i)
  568.           return;
  569.  
  570.         PieceHandler *Hold=Pieces[i];
  571.  
  572.         movmem(&Pieces[0],&Pieces[1],i*sizeof(PieceHandler *));
  573.  
  574.         Pieces[0]=Hold;
  575.  
  576.         VirtualizedInterior();
  577.  
  578.         return;
  579.       }
  580.     }
  581.   }
  582.  
  583.   InfoBox NothingFound;
  584.  
  585.   NothingFound
  586.     + "Sorry, there isn\'t a drawn"
  587.     + "object below the cursor that"
  588.     + "can be pushed back.";
  589.  
  590.   NothingFound.Title("Nothing to Push");
  591.   NothingFound.UseInfoBox();
  592. }
  593.  
  594. //-------------------------------------------------------------------------
  595. //
  596. // Duplicate an object to another location
  597. //
  598. //-------------------------------------------------------------------------
  599.  
  600. void DialogWindow::CopyObject()
  601. {
  602.   if (NumberPieces)
  603.   {
  604.     // Give elements priority for copying
  605.  
  606.     int PromptWidth=0;
  607.  
  608.     for (int i=NumberPieces-1;i>=0;i--)
  609.     {
  610.       PieceHandler &Piece=*Pieces[i];
  611.  
  612.       if (Piece.Prompter && *Piece.Prompter)
  613.       {
  614.         PromptWidth=strlen(Piece.Prompter)-(strchr(Piece.Prompter,'~')?1:0);
  615.       }
  616.  
  617.       if ((CursorX>=Piece.X &&
  618.         CursorY>=Piece.Y &&
  619.         CursorX<Piece.X+Piece.Width &&
  620.         CursorY<Piece.Y+Piece.Height &&
  621.         Piece.LayOut>PieceHandler::__DUMMY__ && Piece.LayOut<PieceHandler::__DUMMY2__) ||
  622.        (PromptWidth && CursorX>=Piece.PromptX &&
  623.         CursorY>=Piece.PromptY &&
  624.         CursorX<Piece.PromptX+PromptWidth &&
  625.         CursorY==Piece.PromptY &&
  626.         Piece.LayOut>PieceHandler::__DUMMY__ && Piece.LayOut<PieceHandler::__DUMMY2__))
  627.           goto JumpIn;
  628.     }
  629.  
  630.     PromptWidth=0;
  631.  
  632.     // If no elements under cursor, jump to remainer of objects in queue
  633.  
  634.     for (i=NumberPieces-1;i>=0;i--)
  635.     {
  636.  
  637. JumpIn:
  638.  
  639.       PieceHandler &Piece=*Pieces[i];
  640.  
  641.       if ((CursorX>=Piece.X && CursorY>=Piece.Y &&
  642.           CursorX<Piece.X+Piece.Width && CursorY<Piece.Y+Piece.Height) ||
  643.           PromptWidth)
  644.       {
  645.         RemoveTheMenus();
  646.  
  647.         Pieces=(PieceHandler **)realloc(Pieces,++NumberPieces*sizeof(char *));
  648.  
  649.         switch (Piece.LayOut)
  650.         {
  651.           case PieceHandler::Box:
  652.             Pieces[NumberPieces-1]=new Box(Piece);
  653.             break;
  654.  
  655.           case PieceHandler::FilledBox:
  656.             Pieces[NumberPieces-1]=new FilledBox(Piece);
  657.             break;
  658.  
  659.           case PieceHandler::HorizontalLine:
  660.             Pieces[NumberPieces-1]=new HorizontalLine(Piece);
  661.             break;
  662.  
  663.           case PieceHandler::VerticalLine:
  664.             Pieces[NumberPieces-1]=new VerticalLine(Piece);
  665.             break;
  666.  
  667.           case PieceHandler::Shadow:
  668.             Pieces[NumberPieces-1]=new Shadow(Piece);
  669.             break;
  670.  
  671.           case PieceHandler::EraseArea:
  672.             Pieces[NumberPieces-1]=new EraseArea(Piece);
  673.             break;
  674.  
  675.           case PieceHandler::ColorizeArea:
  676.             Pieces[NumberPieces-1]=new ColorizeArea(Piece);
  677.             break;
  678.  
  679.           case PieceHandler::Character:
  680.             Pieces[NumberPieces-1]=new Character(Piece);
  681.             break;
  682.  
  683.           case PieceHandler::Integer:
  684.             Pieces[NumberPieces-1]=new Integer(Piece);
  685.             break;
  686.  
  687.           case PieceHandler::Long:
  688.             Pieces[NumberPieces-1]=new Long(Piece);
  689.             break;
  690.  
  691.           case PieceHandler::Float:
  692.             Pieces[NumberPieces-1]=new Float(Piece);
  693.             break;
  694.  
  695.           case PieceHandler::Double:
  696.             Pieces[NumberPieces-1]=new Double(Piece);
  697.             break;
  698.  
  699.           case PieceHandler::Bcd:
  700.             Pieces[NumberPieces-1]=new Bcd(Piece);
  701.             break;
  702.  
  703.           case PieceHandler::Check:
  704.             Pieces[NumberPieces-1]=new Check(Piece);
  705.             break;
  706.  
  707.           case PieceHandler::Push:
  708.             Pieces[NumberPieces-1]=new Push(Piece);
  709.             break;
  710.  
  711.           case PieceHandler::GroupHeading:
  712.             Pieces[NumberPieces-1]=new GroupHeading(Piece);
  713.             break;
  714.  
  715.           case PieceHandler::HRadio:
  716.             Pieces[NumberPieces-1]=new HRadio(Piece);
  717.             break;
  718.  
  719.           case PieceHandler::VRadio:
  720.             Pieces[NumberPieces-1]=new VRadio(Piece);
  721.             break;
  722.  
  723.           case PieceHandler::PickGeneric:
  724.             Pieces[NumberPieces-1]=new PickGeneric(Piece);
  725.             break;
  726.         }
  727.  
  728.         if (Piece.LayOut>PieceHandler::__DUMMY__)
  729.         {
  730.           PieceHandler &PieceCopy=*Pieces[NumberPieces-1];
  731.  
  732.           if (Piece.Mask)
  733.           {
  734.             PieceCopy.Mask=new char[50];
  735.             strcpy(PieceCopy.Mask,Piece.Mask);
  736.           }
  737.  
  738.           if (Piece.Variable)
  739.           {
  740.             PieceCopy.Variable=new char[50];
  741.             strcpy(PieceCopy.Variable,Piece.Variable);
  742.           }
  743.  
  744.           if (Piece.Prompter)
  745.           {
  746.             PieceCopy.Prompter=new char[50];
  747.             strcpy(PieceCopy.Prompter,Piece.Prompter);
  748.           }
  749.  
  750.           if (Piece.HotKey)
  751.           {
  752.             PieceCopy.HotKey=new char[30];
  753.             strcpy(PieceCopy.HotKey,Piece.HotKey);
  754.           }
  755.  
  756.           if (Piece.Text)
  757.           {
  758.             PieceCopy.Text=new char[50];
  759.             strcpy(PieceCopy.Text,Piece.Text);
  760.           }
  761.  
  762.           if (Piece.Constant)
  763.           {
  764.             PieceCopy.Constant=new char[50];
  765.             strcpy(PieceCopy.Constant,Piece.Constant);
  766.           }
  767.  
  768.           if (Piece.Help)
  769.           {
  770.             PieceCopy.Help=new char[65];
  771.             strcpy(PieceCopy.Help,Piece.Help);
  772.           }
  773.  
  774.           if (Piece.DerivedClass)
  775.           {
  776.             PieceCopy.DerivedClass=new char[50];
  777.             strcpy(PieceCopy.DerivedClass,Piece.DerivedClass);
  778.           }
  779.  
  780.           if (Piece.Elements)
  781.           {
  782.             PieceCopy.Elements=new char*[10];
  783.             for (int i=0;i<10;i++)
  784.             {
  785.               PieceCopy.Elements[i]=new char[50];
  786.               strcpy(PieceCopy.Elements[i],Piece.Elements[i]);
  787.             }
  788.           }
  789.         }
  790.  
  791.         VirtualizedInterior();
  792.  
  793.         if (!MoveObject(0,1))
  794.         {
  795.           delete Pieces[--NumberPieces];
  796.           VirtualizedInterior();
  797.         }
  798.  
  799.         return;
  800.       }
  801.     }
  802.   }
  803.  
  804.   InfoBox NothingFound;
  805.  
  806.   NothingFound
  807.     + "Sorry, there isn\'t an"
  808.     + "object below the cursor"
  809.     + "that can be copied.";
  810.  
  811.   NothingFound.Title("Nothing to Copy");
  812.   NothingFound.UseInfoBox();
  813. }
  814.  
  815. //-------------------------------------------------------------------------
  816. //
  817. // Remove an object from the dialog
  818. //
  819. //-------------------------------------------------------------------------
  820.  
  821. void DialogWindow::DeleteObject()
  822. {
  823.   if (NumberPieces)
  824.   {
  825.     // Give elements priority for deletion
  826.  
  827.     int PromptWidth=0;
  828.  
  829.     for (int i=NumberPieces-1;i>=0;i--)
  830.     {
  831.       PieceHandler &Piece=*Pieces[i];
  832.  
  833.       if (Piece.Prompter && *Piece.Prompter)
  834.       {
  835.         PromptWidth=strlen(Piece.Prompter)-(strchr(Piece.Prompter,'~')?1:0);
  836.       }
  837.  
  838.       if ((CursorX>=Piece.X &&
  839.         CursorY>=Piece.Y &&
  840.         CursorX<Piece.X+Piece.Width &&
  841.         CursorY<Piece.Y+Piece.Height &&
  842.         Piece.LayOut>PieceHandler::__DUMMY__ && Piece.LayOut<PieceHandler::__DUMMY2__) ||
  843.        (PromptWidth && CursorX>=Piece.PromptX &&
  844.         CursorY>=Piece.PromptY &&
  845.         CursorX<Piece.PromptX+PromptWidth &&
  846.         CursorY==Piece.PromptY &&
  847.         Piece.LayOut>PieceHandler::__DUMMY__ && Piece.LayOut<PieceHandler::__DUMMY2__))
  848.           goto JumpIn;
  849.     }
  850.  
  851.     PromptWidth=0;
  852.  
  853.     // If no elements under cursor, jump to remainer of objects in queue
  854.  
  855.     for (i=NumberPieces-1;i>=0;i--)
  856.     {
  857.  
  858. JumpIn:
  859.  
  860.       PieceHandler &Piece=*Pieces[i];
  861.  
  862.       if ((CursorX>=Piece.X && CursorY>=Piece.Y &&
  863.         CursorX<Piece.X+Piece.Width && CursorY<Piece.Y+Piece.Height)
  864.         || PromptWidth)
  865.       {
  866.         RemoveTheMenus();
  867.  
  868.         delete Pieces[i];
  869.  
  870.         if (i!=NumberPieces-1)
  871.           movmem(&Pieces[i+1],&Pieces[i],(NumberPieces-i-1)*sizeof(PieceHandler *));
  872.  
  873.         NumberPieces--;
  874.  
  875.         VirtualizedInterior();
  876.  
  877.         return;
  878.       }
  879.     }
  880.   }
  881.  
  882.   InfoBox NothingFound;
  883.  
  884.   NothingFound
  885.     + "Sorry, there is nothing below"
  886.     + "the cursor that can be deleted.";
  887.  
  888.   NothingFound.Title("Nothing to Delete");
  889.   NothingFound.UseInfoBox();
  890. }
  891.  
  892. //-------------------------------------------------------------------------
  893. //
  894. // Recolorize text within a region
  895. //
  896. //-------------------------------------------------------------------------
  897.  
  898. void DialogWindow::ColorText()
  899. {
  900.   RemoveTheMenus();
  901.  
  902.   Blaze.HelpLine(0,"Use the keyboard or mouse to select the region (Esc aborts)");
  903.  
  904.   MousePosition(X+CursorX+1,Y+CursorY+1);
  905.   MouseLocate();
  906.  
  907.   Event EventHandler;
  908.  
  909.   int MouseX=MouseHorizontal;
  910.   int MouseY=MouseVertical;
  911.  
  912.   int Width=1;
  913.   int Height=1;
  914.  
  915.   for (;;)
  916.   {
  917.     Blaze.BoxAttribute(CursorX,CursorY,Width,Height,CurrentColor);
  918.     switch (EventHandler.GetEvent())
  919.     {
  920.       case kbUp:
  921.         if (Height==1)
  922.           continue;
  923.         Height--;
  924.         VirtualizedInterior();
  925.         break;
  926.  
  927.       case kbDown:
  928.         if (CursorY+Height>=Blaze.WhatWinHeight()-1)
  929.           break;
  930.         Height++;
  931.         VirtualizedInterior();
  932.         break;
  933.  
  934.       case kbLeft:
  935.         if (Width==1)
  936.           continue;
  937.         Width--;
  938.         VirtualizedInterior();
  939.         break;
  940.  
  941.       case kbRight:
  942.         if (CursorX+Width>=Blaze.WhatWinWidth()-1)
  943.           break;
  944.         Width++;
  945.         VirtualizedInterior();
  946.         break;
  947.  
  948.       case MousedEvent:
  949.         if (MouseEvent&MouseMoved)
  950.         {
  951.           int NewX=MouseHorizontal-MouseX;
  952.           int NewY=MouseVertical-MouseY;
  953.           MouseX=MouseHorizontal;
  954.           MouseY=MouseVertical;
  955.           Width+=NewX;
  956.           Height+=NewY;
  957.           if (Width<1)
  958.             Width=1;
  959.           if (Height<1)
  960.             Height=1;
  961.  
  962.           if (CursorX+Width>Blaze.WhatWinWidth()-1)
  963.             Width=Blaze.WhatWinWidth()-CursorX;
  964.           if (CursorY+Height>Blaze.WhatWinHeight()-1)
  965.             Height=Blaze.WhatWinHeight()-CursorY;
  966.  
  967.           if (MouseX!=X+CursorX+Width || MouseY!=Y+CursorY+Height)
  968.           {
  969.             MousePosition(X+CursorX+Width,Y+CursorY+Height);
  970.             MouseLocate();
  971.             MouseX=MouseHorizontal;
  972.             MouseY=MouseVertical;
  973.           }
  974.  
  975.           VirtualizedInterior();
  976.         }
  977.         if (MouseEvent&MouseLeftButtonRelease)
  978.           goto ColorChange;
  979.         break;
  980.  
  981.       case kbCr:
  982.         goto ColorChange;
  983.  
  984.       case kbEsc:
  985.         VirtualizedInterior();
  986.         return;
  987.     }
  988.   }
  989.  
  990. ColorChange:
  991.  
  992.   for (int Y=CursorY;Y<CursorY+Height;Y++)
  993.     for (int X=(CursorX*2)+1;X<((CursorX+Width)*2);X+=2)
  994.       *(Interior[Y]+X)=CurrentColor;
  995.  
  996.   VirtualizedInterior();
  997. }
  998.  
  999. //-------------------------------------------------------------------------
  1000. //
  1001. // Copy text within a region to another location
  1002. //
  1003. //-------------------------------------------------------------------------
  1004.  
  1005. void DialogWindow::CopyText()
  1006. {
  1007.   RemoveTheMenus();
  1008.  
  1009.   Blaze.HelpLine(0,"Use the keyboard or mouse to select the copy region (Esc aborts)");
  1010.   MousePosition(X+CursorX+1,Y+CursorY+1);
  1011.   MouseLocate();
  1012.  
  1013.   Event EventHandler;
  1014.  
  1015.   int MouseX=MouseHorizontal;
  1016.   int MouseY=MouseVertical;
  1017.  
  1018.   int Width=1;
  1019.   int Height=1;
  1020.  
  1021.   for (;;)
  1022.   {
  1023.     Blaze.BoxAttribute(CursorX,CursorY,Width,Height,bRed|fYellow);
  1024.     switch (EventHandler.GetEvent())
  1025.     {
  1026.       case kbUp:
  1027.         if (Height==1)
  1028.           continue;
  1029.         Height--;
  1030.         VirtualizedInterior();
  1031.         break;
  1032.  
  1033.       case kbDown:
  1034.         if (CursorY+Height>=Blaze.WhatWinHeight()-1)
  1035.           break;
  1036.         Height++;
  1037.         VirtualizedInterior();
  1038.         break;
  1039.  
  1040.       case kbLeft:
  1041.         if (Width==1)
  1042.           continue;
  1043.         Width--;
  1044.         VirtualizedInterior();
  1045.         break;
  1046.  
  1047.       case kbRight:
  1048.         if (CursorX+Width>=Blaze.WhatWinWidth()-1)
  1049.           break;
  1050.         Width++;
  1051.         VirtualizedInterior();
  1052.         break;
  1053.  
  1054.       case MousedEvent:
  1055.         if (MouseEvent&MouseMoved)
  1056.         {
  1057.           int NewX=MouseHorizontal-MouseX;
  1058.           int NewY=MouseVertical-MouseY;
  1059.           MouseX=MouseHorizontal;
  1060.           MouseY=MouseVertical;
  1061.           Width+=NewX;
  1062.           Height+=NewY;
  1063.           if (Width<1)
  1064.             Width=1;
  1065.           if (Height<1)
  1066.             Height=1;
  1067.           VirtualizedInterior();
  1068.  
  1069.           if (CursorX+Width>Blaze.WhatWinWidth()-1)
  1070.             Width=Blaze.WhatWinWidth()-CursorX;
  1071.           if (CursorY+Height>Blaze.WhatWinHeight()-1)
  1072.             Height=Blaze.WhatWinHeight()-CursorY;
  1073.  
  1074.           if (MouseX!=X+CursorX+Width || MouseY!=Y+CursorY+Height)
  1075.           {
  1076.             MousePosition(X+CursorX+Width,Y+CursorY+Height);
  1077.             MouseLocate();
  1078.             MouseX=MouseHorizontal;
  1079.             MouseY=MouseVertical;
  1080.           }
  1081.         }
  1082.         if (MouseEvent&MouseLeftButtonRelease)
  1083.           goto CopyIt;
  1084.         break;
  1085.  
  1086.       case kbCr:
  1087.         goto CopyIt;
  1088.  
  1089.       case kbEsc:
  1090.         VirtualizedInterior();
  1091.         return;
  1092.     }
  1093.   }
  1094.  
  1095. CopyIt:
  1096.  
  1097.   int CurrentX=CursorX;
  1098.   int CurrentY=CursorY;
  1099.  
  1100.   char (*DuplicateInterior)[400]=new char[61][sizeof(DuplicateInterior[0])];
  1101.  
  1102.   memcpy(DuplicateInterior,Interior,sizeof(DuplicateInterior[0])*60);
  1103.  
  1104.   Blaze.HelpLine(0,"Use the keyboard or mouse to select the copy location (Esc aborts)");
  1105.  
  1106.   int WinX=X, WinY=Y;
  1107.   MousePosition(X+CursorX+1,Y+CursorY+1);
  1108.   MouseLocate();
  1109.  
  1110.   MouseX=MouseHorizontal;
  1111.   MouseY=MouseVertical;
  1112.  
  1113.   for (;;)
  1114.   {
  1115.     memcpy(Interior,DuplicateInterior,sizeof(DuplicateInterior[0])*60);
  1116.  
  1117.     for (int Y=CursorY,Z=CurrentY;Y<CursorY+Height;Y++,Z++)
  1118.     {
  1119.       for (int X=CursorX,U=CurrentX;X<CursorX+Width;X++,U++)
  1120.       {
  1121.         if (*(DuplicateInterior[Y]+(X*2)))
  1122.         {
  1123.           *(Interior[Z]+(U*2))=*(DuplicateInterior[Y]+(X*2));
  1124.           *(Interior[Z]+(U*2)+1)=*(DuplicateInterior[Y]+(X*2)+1);
  1125.         }
  1126.       }
  1127.     }
  1128.  
  1129.     VirtualizedInterior();
  1130.     Blaze.BoxAttribute(CurrentX,CurrentY,Width,Height,bRed|fYellow);
  1131.  
  1132.     switch (EventHandler.GetEvent())
  1133.     {
  1134.       case kbUp:
  1135.         if (!CurrentY)
  1136.           continue;
  1137.         CurrentY--;
  1138.         break;
  1139.  
  1140.       case kbDown:
  1141.         if (CurrentY>=Blaze.WhatWinHeight()-1)
  1142.           CurrentY=Blaze.WhatWinHeight()-1;
  1143.         CurrentY++;
  1144.         break;
  1145.  
  1146.       case kbLeft:
  1147.         if (!CurrentX)
  1148.           continue;
  1149.         CurrentX--;
  1150.         break;
  1151.  
  1152.       case kbRight:
  1153.         if (CurrentX>=Blaze.WhatWinWidth()-1)
  1154.           CurrentX=Blaze.WhatWinWidth()-1;
  1155.         CurrentX++;
  1156.         break;
  1157.  
  1158.       case MousedEvent:
  1159.         if (MouseEvent&MouseMoved)
  1160.         {
  1161.           int NewX=MouseHorizontal-MouseX;
  1162.           int NewY=MouseVertical-MouseY;
  1163.           MouseX=MouseHorizontal;
  1164.           MouseY=MouseVertical;
  1165.           CurrentX+=NewX;
  1166.           CurrentY+=NewY;
  1167.           if (CurrentY<0)
  1168.             CurrentY=0;
  1169.           if (CurrentX<0)
  1170.             CurrentX=1;
  1171.  
  1172.           if (CurrentX>Blaze.WhatWinWidth()-1)
  1173.             CurrentX=Blaze.WhatWinWidth()-1;
  1174.           if (CurrentY>Blaze.WhatWinHeight()-1)
  1175.             CurrentY=Blaze.WhatWinHeight()-1;
  1176.  
  1177.           if (MouseX!=WinX+CurrentX+1 || MouseY!=WinY+CurrentY+1)
  1178.           {
  1179.             MousePosition(WinX+CurrentX+1,WinY+CurrentY+1);
  1180.             MouseLocate();
  1181.             MouseX=MouseHorizontal;
  1182.             MouseY=MouseVertical;
  1183.           }
  1184.         }
  1185.         if (MouseEvent&MouseLeftButtonRelease)
  1186.           goto OutaHere;
  1187.         break;
  1188.  
  1189.       case kbCr:
  1190.         goto OutaHere;
  1191.  
  1192.       case kbEsc:
  1193.         memcpy(Interior,DuplicateInterior,sizeof(DuplicateInterior[0])*60);
  1194.         delete DuplicateInterior;
  1195.         VirtualizedInterior();
  1196.         return;
  1197.     }
  1198.   }
  1199.  
  1200. OutaHere:
  1201.  
  1202.   delete DuplicateInterior;
  1203.  
  1204.   VirtualizedInterior();
  1205. }
  1206.  
  1207. //-------------------------------------------------------------------------
  1208. //
  1209. // Move text within a region to another location and remove it from the
  1210. // original location
  1211. //
  1212. //-------------------------------------------------------------------------
  1213.  
  1214. void DialogWindow::MoveText()
  1215. {
  1216.   RemoveTheMenus();
  1217.  
  1218.   Blaze.HelpLine(0,"Use the keyboard or mouse to select the move region (Esc aborts)");
  1219.   MousePosition(X+CursorX+1,Y+CursorY+1);
  1220.   MouseLocate();
  1221.  
  1222.   Event EventHandler;
  1223.  
  1224.   int MouseX=MouseHorizontal;
  1225.   int MouseY=MouseVertical;
  1226.  
  1227.   int Width=1;
  1228.   int Height=1;
  1229.  
  1230.   for (;;)
  1231.   {
  1232.     Blaze.BoxAttribute(CursorX,CursorY,Width,Height,bRed|fYellow);
  1233.     switch (EventHandler.GetEvent())
  1234.     {
  1235.       case kbUp:
  1236.         if (Height==1)
  1237.           continue;
  1238.         Height--;
  1239.         VirtualizedInterior();
  1240.         break;
  1241.  
  1242.       case kbDown:
  1243.         if (CursorY+Height>=Blaze.WhatWinHeight()-1)
  1244.           Height=Blaze.WhatWinHeight()-CursorY;
  1245.         Height++;
  1246.         VirtualizedInterior();
  1247.         break;
  1248.  
  1249.       case kbLeft:
  1250.         if (Width==1)
  1251.           continue;
  1252.         Width--;
  1253.         VirtualizedInterior();
  1254.         break;
  1255.  
  1256.       case kbRight:
  1257.         if (CursorX+Width>=Blaze.WhatWinWidth()-1)
  1258.           Width=Blaze.WhatWinWidth()-CursorX;
  1259.         Width++;
  1260.         VirtualizedInterior();
  1261.         break;
  1262.  
  1263.       case MousedEvent:
  1264.         if (MouseEvent&MouseMoved)
  1265.         {
  1266.           int NewX=MouseHorizontal-MouseX;
  1267.           int NewY=MouseVertical-MouseY;
  1268.           MouseX=MouseHorizontal;
  1269.           MouseY=MouseVertical;
  1270.           Width+=NewX;
  1271.           Height+=NewY;
  1272.           if (Width<1)
  1273.             Width=1;
  1274.           if (Height<1)
  1275.             Height=1;
  1276.           VirtualizedInterior();
  1277.  
  1278.           if (CursorX+Width>Blaze.WhatWinWidth()-1)
  1279.             Width=Blaze.WhatWinWidth()-CursorX;
  1280.           if (CursorY+Height>Blaze.WhatWinHeight()-1)
  1281.             Height=Blaze.WhatWinHeight()-CursorY;
  1282.  
  1283.           if (MouseX!=X+CursorX+Width || MouseY!=Y+CursorY+Height)
  1284.           {
  1285.             MousePosition(X+CursorX+Width,Y+CursorY+Height);
  1286.             MouseLocate();
  1287.             MouseX=MouseHorizontal;
  1288.             MouseY=MouseVertical;
  1289.           }
  1290.         }
  1291.         if (MouseEvent&MouseLeftButtonRelease)
  1292.           goto CopyIt;
  1293.         break;
  1294.  
  1295.       case kbCr:
  1296.         goto CopyIt;
  1297.  
  1298.       case kbEsc:
  1299.         VirtualizedInterior();
  1300.         return;
  1301.     }
  1302.   }
  1303.  
  1304. CopyIt:
  1305.  
  1306.   int CurrentX=CursorX;
  1307.   int CurrentY=CursorY;
  1308.  
  1309.   char (*DuplicateInterior)[400]=new char[61][sizeof(DuplicateInterior[0])];
  1310.  
  1311.   memcpy(DuplicateInterior,Interior,sizeof(DuplicateInterior[0])*60);
  1312.  
  1313.   Blaze.HelpLine(0,"Use the keyboard or mouse to select the move location (Esc aborts)");
  1314.  
  1315.   int WinX=X, WinY=Y;
  1316.   MousePosition(X+CursorX+1,Y+CursorY+1);
  1317.   MouseLocate();
  1318.  
  1319.   MouseX=MouseHorizontal;
  1320.   MouseY=MouseVertical;
  1321.  
  1322.   for (;;)
  1323.   {
  1324.     memcpy(Interior,DuplicateInterior,sizeof(DuplicateInterior[0])*60);
  1325.  
  1326.     for (int YY=CursorY;YY<CursorY+Height;YY++)
  1327.       memset((Interior[YY]+(CursorX*2)),0,Width*2);
  1328.  
  1329.     for (int Y=CursorY,Z=CurrentY;Y<CursorY+Height;Y++,Z++)
  1330.     {
  1331.       for (int X=CursorX,U=CurrentX;X<CursorX+Width;X++,U++)
  1332.       {
  1333.         if (*(DuplicateInterior[Y]+(X*2)))
  1334.         {
  1335.           *(Interior[Z]+(U*2))=*(DuplicateInterior[Y]+(X*2));
  1336.           *(Interior[Z]+(U*2)+1)=*(DuplicateInterior[Y]+(X*2)+1);
  1337.         }
  1338.       }
  1339.     }
  1340.  
  1341.     VirtualizedInterior();
  1342.     Blaze.BoxAttribute(CurrentX,CurrentY,Width,Height,bRed|fYellow);
  1343.  
  1344.     switch (EventHandler.GetEvent())
  1345.     {
  1346.       case kbUp:
  1347.         if (!CurrentY)
  1348.           continue;
  1349.         CurrentY--;
  1350.         break;
  1351.  
  1352.       case kbDown:
  1353.         if (CurrentY>=Blaze.WhatWinHeight()-1)
  1354.           CurrentY=Blaze.WhatWinHeight()-1;
  1355.         CurrentY++;
  1356.         break;
  1357.  
  1358.       case kbLeft:
  1359.         if (!CurrentX)
  1360.           continue;
  1361.         CurrentX--;
  1362.         break;
  1363.  
  1364.       case kbRight:
  1365.         if (CurrentX>=Blaze.WhatWinWidth()-1)
  1366.           CurrentX=Blaze.WhatWinWidth()-1;
  1367.         CurrentX++;
  1368.         break;
  1369.  
  1370.       case MousedEvent:
  1371.         if (MouseEvent&MouseMoved)
  1372.         {
  1373.           int NewX=MouseHorizontal-MouseX;
  1374.           int NewY=MouseVertical-MouseY;
  1375.           MouseX=MouseHorizontal;
  1376.           MouseY=MouseVertical;
  1377.           CurrentX+=NewX;
  1378.           CurrentY+=NewY;
  1379.           if (CurrentY<0)
  1380.             CurrentY=0;
  1381.           if (CurrentX<0)
  1382.             CurrentX=1;
  1383.  
  1384.           if (CurrentX>Blaze.WhatWinWidth()-1)
  1385.             CurrentX=Blaze.WhatWinWidth()-1;
  1386.           if (CurrentY>Blaze.WhatWinHeight()-1)
  1387.             CurrentY=Blaze.WhatWinHeight()-1;
  1388.  
  1389.           if (MouseX!=WinX+CurrentX+1 || MouseY!=WinY+CurrentY+1)
  1390.           {
  1391.             MousePosition(WinX+CurrentX+1,WinY+CurrentY+1);
  1392.             MouseLocate();
  1393.             MouseX=MouseHorizontal;
  1394.             MouseY=MouseVertical;
  1395.           }
  1396.         }
  1397.         if (MouseEvent&MouseLeftButtonRelease)
  1398.           goto OutaHere;
  1399.         break;
  1400.  
  1401.       case kbCr:
  1402.         goto OutaHere;
  1403.  
  1404.       case kbEsc:
  1405.         memcpy(Interior,DuplicateInterior,sizeof(DuplicateInterior[0])*60);
  1406.         delete DuplicateInterior;
  1407.         VirtualizedInterior();
  1408.         return;
  1409.     }
  1410.   }
  1411.  
  1412. OutaHere:
  1413.  
  1414.   delete DuplicateInterior;
  1415.  
  1416.   VirtualizedInterior();
  1417. }
  1418.