home *** CD-ROM | disk | FTP | other *** search
/ Windoware / WINDOWARE_1_6.iso / winutil / project / projwind.cls < prev    next >
Text File  |  1990-05-24  |  30KB  |  1,063 lines
  1. /* Maintain a Project chart in a Window. The ProjWindow is
  2.    responsible for all drawing of the project. The window 
  3.    has full scrolling and supports a keyboard interface.
  4.    If topMethod or botMethod are set, then the corresponding
  5.    method will be executed for each activity while displaying
  6.    the project.
  7.  
  8.    ProjWindow descends from class Window and inherits all of
  9.    its instance variables and methods.
  10.  
  11.    All strings are defined as resources for easy translation.
  12. */!!
  13.  
  14. inherit(Window, #ProjWindow, #(project     /* the project */
  15. fileName    /* of the project */
  16. actions     /* menu actions table */
  17. dirty       /* true if not saved */
  18. view        /* normal or zoomed */
  19. boxHeight   /* based on scrnsize */
  20. boxWidth    /* adjustable for zoom */
  21. boxHSpace   /* adjustable */
  22. activWidth  /* adjustable */
  23. hScrollPos  /* horiz scroll posn */
  24. vScrollPos  /* vert scroll posn */
  25. maxVisCol   /* max visible col */
  26. maxVisRow   /* max visible row */
  27. methTable   /* table of methods */
  28. topMethod   /* offset into table */
  29. botMethod   /* offset into table */
  30. gw          /* a GanttWindow */
  31. /* these are new for dragging */
  32. dragDC      /* for drawing */
  33. anchorPt    /* starting point */
  34. oldPt       /* end point */
  35. ), 2, nil)!!
  36.  
  37. now(ProjWindowClass)!!
  38.  
  39. /* Return the name of this class's MS-Windows window class
  40.   either for registration or new window creation. */
  41. Def wndClass(self)
  42. { ^"ProjWindow"  }!!
  43.  
  44. /* Create a new window class Struct.
  45.    Change the cursor to a cross.  */
  46. Def newWClass(self, lpCl, lpIcon | wc)
  47. { wc := newWClass(self:WindowClass, lpCl, lpIcon);
  48.   putWord(wc, Call LoadCursor(0, IDC_CROSS), 14);
  49.   ^wc;
  50. } !!
  51.  
  52. now(ProjWindow)!!
  53.  
  54. /* Allow the user to change the printer setup. */
  55. Def printerSetup(self | prn)
  56. { 
  57.   prn := new(Printer);
  58.   getPrinterParms(prn);
  59.   deviceMode(prn, self);
  60. }
  61. !!
  62.  
  63. /* Respond to menu choice to run a program. 
  64.    By default, run MSDOS executive shell.*/
  65. Def run(self | dlg, progName)
  66. {
  67.   dlg := new(InputDialog, "Run","Program name:","MSDOS.EXE");
  68.   if runModal(dlg, INPUT_BOX, self) == IDOK
  69.     progName:=getText(dlg);
  70.     exec(progName);
  71.   endif;
  72. }!!
  73.  
  74. /* Handles menu choice to set colors. Global variables
  75.    CritColor and SlackColor determine the application
  76.    colors. */
  77. Def toggleColor(self)
  78. {
  79.   if CritColor <> BLACK
  80.     unCheckMenuItem(self, PW_COLOR);
  81.     CritColor := BLACK;
  82.     SlackColor := BLACK;
  83.   else
  84.     checkMenuItem(self, PW_COLOR);
  85.     CritColor := RED;
  86.     SlackColor := BLUE;
  87.   endif;
  88.   invalidate(self);
  89.   if gw invalidate(gw); endif;
  90. }!!
  91.  
  92. /* Create a new Milestone */
  93. Def newMilestone(self)
  94. {
  95.   newActivity(self, Milestone);
  96. }!!
  97.  
  98. /* Create the window using a "main" window style. */
  99. Def create(self, par, wName, rect, style)
  100. { 
  101.   ^create(self:Window, nil, wName, rect, 
  102.      WS_OVERLAPPEDWINDOW bitOr WS_VSCROLL bitOr WS_HSCROLL);
  103. }!!
  104.  
  105. /* Set up a dummy project, menus and the method table. */
  106. Def init(self)
  107. {  
  108.   setProject(self, new(Project));
  109.   setAutoCalc(project, true);  
  110.   setView(self, #normal);
  111.   setScrollBars(self);
  112.   setMenus(self);
  113.   checkMenuItem(self, PW_AUTOCALC);
  114.   checkMenuItem(self, PW_COLOR);
  115.   setMethTable(self);
  116. }!!
  117.  
  118. /* Set the project. */
  119. Def setProject(self, aProject)
  120. {
  121.   project := aProject;
  122. }!!
  123.  
  124. /* Set the resolution for the size of nodes, spacing etc.
  125.    based on the font text size.  There are two views,
  126.    normal and small.  Both are based on text font size so
  127.    that they will display adequately with any resolution. */
  128. Def setView(self, aView | hDC, ts)
  129. {
  130.   view := aView;
  131.   hDC := getContext(self);    /* so we can get text size */
  132.   ts := textSize(self, hDC);  /* x is width, y is height */
  133.   releaseContext(self, hDC);
  134.   if view == #small
  135.     boxWidth := x(ts) * 4;
  136.     boxHSpace := x(ts)/2 + 1;
  137.     boxHeight := y(ts) + 4;
  138.   else
  139.     boxWidth := asInt(x(ts)*8);
  140.     boxHSpace := x(ts) + 2;
  141.     boxHeight := y(ts) * 2;   
  142.   endif;
  143.   activWidth := boxWidth + boxHSpace;
  144.   reSize(self, 0, 0L);        /* so scrolling is adjusted */
  145. }!!
  146.  
  147. /* Set the scroll bar ranges and initial positions. */
  148. Def setScrollBars(self)
  149. { 
  150.   Call SetScrollRange(hWnd, SB_HORZ, 0, PW_MAX_COLS, 0);
  151.   Call SetScrollRange(hWnd, SB_VERT, 0, PW_MAX_ROWS, 0);
  152.   hScrollPos := vScrollPos := 0; 
  153. }!!
  154.  
  155. /* Set up the method table used for display options. 
  156.    Each of these methods should be applicable to all
  157.    activities in the project, that is, both Milestones
  158.    and Tasks. */
  159. Def setMethTable(self)
  160. {
  161.     methTable := #(#getTime, 
  162.                    #getSlack, 
  163.                    #getCost,
  164.                    #getEarlyStart,
  165.                    #getEarlyFinish,
  166.                    #getLateStart,
  167.                    #getLateFinish);
  168.   topMethod := 3;
  169. }!!
  170.  
  171. /* Set the method to display info below each box. 
  172.    The offset refers to the position in the
  173.    methTable. */
  174. Def setBotMethod(self, offset)
  175. {
  176.   botMethod := offset;
  177. }!!
  178.  
  179. /* Set the method to display info atop each box. 
  180.    The offset refers to the position in the
  181.    methTable. */
  182. Def setTopMethod(self, offset)
  183. {
  184.   topMethod := offset;
  185. }!!
  186.  
  187. /* Add an about box and load menu resources.
  188.    Set up the menu actions table. Each entry
  189.    consists of a constant ID and a message
  190.    that will be performed. */
  191. Def setMenus(self)
  192. {
  193.   addAbout(self);
  194.   loadMenu(self, "PWMenus");
  195.   setMenu(self, hMenu);
  196.  
  197.   actions := new(Dictionary, 30);
  198.  
  199.   add(actions, PW_FILE_NEW, #fileNew);
  200.   add(actions, PW_FILE_OPEN, #fileOpenAs);
  201.   add(actions, PW_FILE_SAVE, #fileSave);
  202.   add(actions, PW_FILE_SAVEAS, #fileSaveAs);
  203.   add(actions, PW_FILE_PRINT, #print);
  204.   add(actions, PW_FILE_PRINT_GRAPH, #printGraphs);
  205.   add(actions, PW_FILE_SETTINGS, #printerSetup);
  206.   add(actions, PW_RUN, #run);
  207.   add(actions, PW_FILE_QUIT, #close);
  208.   add(actions, PW_CLIP, #clipChart);
  209.   add(actions, PW_ABOUT_ACTOR, #aboutActor);
  210.   add(actions, PW_DEL_ACTIVITY, #deleteActivity);
  211.   add(actions, PW_DEL_RESOURCE, #deleteResource);
  212.   add(actions, PW_NEW_MSTONE, #newMilestone);
  213.   add(actions, PW_NEW_TASK, #newTask);
  214.   add(actions, PW_NEW_PERT, #newPERTTask);
  215.   add(actions, PW_DISPLAY, #displaySettings);
  216.   add(actions, PW_COLOR, #toggleColor);
  217.   add(actions, PW_AUTOCALC, #autoCalc);
  218.   add(actions, PW_CALC, #recalc);
  219.   add(actions, PW_SHOWROOM, #showRoom);
  220.   add(actions, PW_ZOOM, #zoom);
  221.   add(actions, PW_VIEW_SUMMARY, #viewSummary);
  222.   add(actions, PW_VIEW_ACTIVITIES, #showActivities);
  223.   add(actions, PW_VIEW_GANTT, #gantt);
  224.   add(actions, PW_VIEW_RESOURCES, #showResources);
  225.   add(actions, PW_VIEW_RESOURCE, #editResource);
  226.  
  227.     /* keyboard accelerator commands */
  228.     
  229.   add(actions, PW_HELP, #help);
  230.   add(actions, EDIT_HOME, #home);
  231.   add(actions, PW_COMMAND_MODE, #commandMode);
  232. }!!
  233.  
  234. /* Convert window coordinates to relative display coordinates. */
  235. Def windowToDisplay(self, wPoint)
  236. {
  237.   ^point((x(wPoint) - boxHSpace) / activWidth  + hScrollPos,
  238.          (y(wPoint) - boxHeight) / (boxHeight*2) + vScrollPos);
  239. }!!
  240.  
  241. /* Convert relative display entries to window coordinates. 
  242.    Uses dot notation for speed. */
  243. Def displayToWindow(self, dPoint)
  244. {
  245.    ^point(boxHSpace + (dPoint.x - hScrollPos) * activWidth,
  246.           boxHeight + (dPoint.y - vScrollPos) * boxHeight*2);          
  247. }!!
  248.  
  249. /* The name of application, used for captions. */
  250. Def  appName(self)
  251. { 
  252.   ^loadString(PW_APPNAME);
  253. }!!
  254.  
  255. /* Check if there is a file error and display an error box. 
  256.    Return the error number, 0 for no error. */
  257. Def checkError(self, aFile | errNo)
  258. {
  259.    errNo := getError(aFile);
  260.    if errNo <> 0
  261.      beep();
  262.      errorBox(loadString(PW_FILEERR1),
  263.               loadString(PW_FILEERR2) + asString(aFile) +
  264.               loadString(PW_FILEERR3) + asString(errNo) +
  265.               loadString(50+errNo));
  266.    endif;
  267.    ^errNo;
  268. }!!
  269.  
  270. /* Returns true if the node is visible in the window.
  271.    Used to speed up redrawing. Uses dot notation for speed. */
  272. Def visible(self, aNode)
  273. { 
  274.   ^between(aNode.x, hScrollPos, maxVisCol + hScrollPos)
  275.      cand between(aNode.y, vScrollPos, maxVisRow + vScrollPos);
  276. }!!
  277.  
  278. /* Set up the cursor for use even if there is no mouse. */
  279. Def gotFocus(self, prevHwnd)
  280. { 
  281.   Call ShowCursor(1);
  282. }!!
  283.  
  284. /* Return to normal use of cursor.  */
  285. Def losingFocus(self, hWndNew)
  286. { 
  287.   Call ShowCursor(0);
  288. } !!
  289.  
  290. /* Check if the project has been saved. */
  291. Def shouldClose(self)
  292. { 
  293.   ^checkClean(self)
  294. }!!
  295.  
  296. /* Make sure the window knows that the project has changed. */
  297. Def dirty(self)
  298. {
  299.   invalidate(self);
  300.   dirty := true;
  301.   if gw
  302.     invalidate(gw);
  303.   endif;
  304. }!!
  305.  
  306. /* Returns boolean value true if the project has
  307.    not changed since last save.  If it is dirty,
  308.    the user is prompted for confirmation.  */
  309. Def checkClean(self)
  310. {
  311.   ^ not(dirty) cor 
  312.      yesNoBox(loadString(PW_WARNING),
  313.               loadString(PW_DISCARD)) == IDYES;
  314. }!!
  315.  
  316. /* Get the offset of the botMethod. */
  317. Def getBotMethod(self)
  318. {
  319.   ^botMethod;
  320. }!!
  321.  
  322. /* Get the offset of the topMethod. */
  323. Def getTopMethod(self)
  324. {
  325.   ^topMethod;
  326. }!!
  327.  
  328. /* Resize the window.  Adjust visible rows and cols. */
  329. Def reSize(self, wp, lp)
  330. { 
  331.   maxVisRow := bottom(clientRect(self)) / (boxHeight*2);
  332.   maxVisCol := right(clientRect(self)) / activWidth;
  333. }!!
  334.  
  335. /* Respond to MS-Windows messages to paint the window. 
  336.    Show the project as a network chart.
  337.    Draw each visible node in its proper position. 
  338.    Display the name and any other info required.
  339.    Then draw the lines to connect the outputs.
  340.    
  341.    The displayToWindow message converts a node's
  342.    logical display position to windows coordinates.
  343.    
  344.    This could be further speeded up by repainting 
  345.    only the invalid rectangle.
  346. */
  347. Def paint(self, hDC |wPoint, x, y)
  348. {
  349.   do(nodes(project), 
  350.    {using(aNode)
  351.    
  352.    wPoint := displayToWindow(self, pos(aNode));
  353.    x := x(wPoint);    /* horiz windows posn */
  354.    y := y(wPoint);    /* vert windows posn */
  355.     
  356.    if visible(self, aNode)
  357.      draw(aNode, self, x, y, hDC);  /* node knows how to draw */ 
  358.      drawTextInfo(self, aNode, x, y, hDC);
  359.    endIf;
  360.    /* always draw connections since they may be visible */
  361.    drawConnections(self, aNode, x, y, getOutputs(aNode), hDC);
  362.   }); 
  363. }!!
  364.  
  365. /* Draw lines connecting the nodes in the window. 
  366.    Uses early binding, dot notation and direct
  367.    Windows calls for speed. */
  368. Def drawConnections(self, aNode, x, y, connectedNodes, hDC | wPoint)
  369. {
  370.      do(connectedNodes,
  371.        {using(output)  
  372.         Call MoveTo(hDC,  x + boxWidth, y + boxHeight/2);
  373.         wPoint := displayToWindow(self:ProjWindow, pos(output));
  374.         Call LineTo(hDC, wPoint.x, wPoint.y + boxHeight/2);
  375.  
  376.         if critical(aNode:Activity) cand critical(output:Activity)  
  377.           Call MoveTo(hDC,  x + boxWidth, y + boxHeight/2+1);
  378.           Call LineTo(hDC, wPoint.x, wPoint.y + boxHeight/2+1);
  379.         endif;       
  380.      });   
  381. }!!
  382.  
  383. /* Draw text info in the window.  If the small view is
  384.    being used, show less information.
  385.    Uses early binding and dot notation for speed. */
  386. Def drawTextInfo(self, aNode, x, y, hDC | ts, str, strSize, offsetY, offsetX)
  387. {
  388.  ts := textSize(self, hDC);
  389.  offsetY := (boxHeight - ts.y) / 2;
  390.  strSize := boxWidth / ts.x;
  391.  if view == #small
  392.    offsetX := 2;   /* to make milestones look ok */
  393.  else
  394.    offsetX := 0;
  395.  endif;
  396.  
  397.  str := subString(aNode.name, 0, strSize-1);
  398.  Call SetTextColor(hDC, SlackColor);
  399.  Call TextOut(hDC, x + offsetX + 2, y + offsetY, str, size(str));     
  400.  
  401.  if critical(aNode)
  402.    Call SetTextColor(hDC, CritColor);
  403.  endif;
  404.  
  405.  if topMethod     /* display above box */
  406.    str := subString(asString(perform(aNode, methTable[topMethod])),0,strSize);
  407.    Call TextOut(hDC, x + 2, y - ts.y, str, size(str));
  408.  endif;
  409.  
  410.  if view ~= #small
  411.  cand botMethod     /* display below box */
  412.      str :=  subString(asString(perform(aNode, methTable[botMethod])),0,strSize);
  413.      Call TextOut(hDC, x + 2, y + boxHeight, str, size(str));
  414.  endif;
  415. }!!
  416.  
  417. /* Draw a task in the window. 
  418.    Uses early binding and direct Windows call for speed. */
  419. Def drawTask(self, aNode, x, y, hDC)
  420. {
  421.   Call Rectangle(hDC, x, y, x + boxWidth, y + boxHeight); 
  422.   if critical(aNode:Activity)
  423.     Call Rectangle(hDC, x+1, y+1, x + boxWidth-1, y + boxHeight-1);
  424.   endif;
  425. }!!
  426.  
  427. /* Draw a milestone in the window. 
  428.    Uses early binding and direct Windows call for speed. */
  429. Def drawMilestone(self, aNode, x, y, hDC)
  430. {
  431.   Call RoundRect(hDC, x, y, x + boxWidth, y + boxHeight, 20,20);
  432.   if critical(aNode:Activity)
  433.     Call RoundRect(hDC, x+1, y+1, x + boxWidth-1, y + boxHeight-1, 17,17);
  434.   endif;     
  435. }!!
  436.  
  437. /* Handle menu events, accelerator keys.
  438.    Lookup the ID in the actions table, if found
  439.    perform it.  */
  440. Def command(self, wp, lp)
  441. {
  442.   if actions[wp]
  443.     perform(self, actions[wp]);
  444.   else  /* these keys might be accelerators */
  445.     if wp == VK_UP  cor wp == VK_DOWN cor
  446.        wp == VK_RIGHT cor wp == VK_LEFT
  447.       WM_KEYDOWN(self, wp, lp);
  448.     else
  449.       beep();  /* internal error! */
  450.       errorBox(loadString(PW_ERROR1),
  451.         loadString(PW_ERROR2) + asString(wp));
  452.     endif;
  453.   endif;
  454. }!!
  455.  
  456. /* Go into "command mode" in response to a slash key accelerator.
  457.    This simulates Lotus 1-2-3 style commands by sending an
  458.    ALT key sysCommand message. */
  459. Def commandMode(self)
  460. { 
  461.   WM_SYSCOMMAND(self, 0xF100, 0L);
  462. }!!
  463.  
  464. /* Get a filename from the user in responds to menu event.
  465.    If the file has changed, check with the user.
  466.    Send a fileOpen message to do the work. */
  467. /* Respond to menu choice to create a new project. */
  468. Def fileNew(self)
  469. {
  470.   if checkClean(self)
  471.     if gw
  472.       close(gw);
  473.     endif;
  474.     fileName := nil;
  475.     dirty := nil;  
  476.     setProject(self, new(Project));
  477.     checkMenuItem(self, PW_AUTOCALC);
  478.     setAutoCalc(project, true);
  479.     setText(self, appName(self));   
  480.     editInfo(project);
  481.     invalidate(self);
  482.   endif;
  483. }!!
  484.  
  485. /* Prompt the user for the filename to open.
  486.    Use the new combo box type of file dialog. */
  487. Def fileOpenAs(self | dlg, file, reader)
  488. {
  489.   if checkClean(self)
  490.     dlg := new(FileDialog, "*."+loadString(PW_EXTENSION));
  491.     if runModal(dlg, FILE_BOX, self) == IDOK
  492.       fileName := loadFile(dlg);    
  493.       fileOpen(self, fileName);
  494.     endif;
  495.   endif;
  496. }!!
  497.  
  498. /* Open the file named fName and read a project from disk.
  499.    If a DOS error occurs (like file not found) then stop.
  500.    Uses the Language Extensions I object storage facility. 
  501.    This method copies the file into a stream so that it
  502.    can read faster.  Also, the old project, file and stream
  503.    are set to nil as soon as possible to free up memory. */
  504. Def fileOpen(self, fName | dlg, file, strm, reader)
  505. {
  506.   showWaitCurs();                       /* this takes a while */
  507.   if gw
  508.     close(gw);                          /* close old GanttWindow */
  509.   endif;      
  510.   file := new(File);                    /* open the file etc. */
  511.   setName(file, fName);
  512.   open(file, 0);
  513.   if checkError(self, file) == 0        /* no DOS errors */
  514.     project := nil;                     /* free up memory */        
  515.   
  516.     strm := streamOver(copyFrom(file, 0, length(file))); 
  517.     close(file);
  518.     setText(self, appName(self)+": " + fName);  
  519.     reader := new(StoredObjectReader);
  520.     project := readFrom(reader, strm);  /* read the project */
  521.     strm := nil;                        /* free up memory */
  522.     setAutoCalc(project, true);         /* other settings */
  523.     checkMenuItem(self, PW_AUTOCALC);
  524.     dirty := nil;
  525.     invalidate(self);                   /* redraw the window */
  526.   else
  527.     fileName := nil;                    /* due to DOS error */
  528.   endif;
  529.   showOldCurs();                        /* all done */
  530. }!!
  531.  
  532. /* Respond to menu choice to save the file.  If the file
  533.    isn't yet named, prompt the user for a name. */
  534. Def fileSave(self)
  535. {
  536.   if fileName
  537.     fileSaveIt(self, fileName);
  538.   else
  539.     fileSaveAs(self);
  540.   endif;
  541. }!!
  542.  
  543. /* Save the project to disk with a new name. */
  544. Def fileSaveAs(self | dlg)
  545. {
  546.   if not(fileName)
  547.      fileName := getName(project)+"."+loadString(PW_EXTENSION);
  548.   endif;
  549.   dlg := new(InputDialog, loadString(PW_APPNAME),
  550.              loadString(PW_SAVEPROJ), fileName);
  551.   if runModal(dlg, INPUT_BOX, self) == IDOK         
  552.      fileName := getText(dlg);
  553.      fileSaveIt(self, fileName);
  554.   endif;
  555. }!!
  556.  
  557. /* Save the project to disk with the filename fName. 
  558.    If a DOS error occurs (like file not found) stop. 
  559.    Uses the Language Extensions I object storage facility. 
  560.    Note: this will not save any global variables!  */
  561. Def fileSaveIt(self, fName | file)
  562. {
  563.   showWaitCurs();                          /* this takes a while */
  564.   file := new(File);                       
  565.   setName(file, fName);
  566.   create(file);
  567.   if checkError(self, file) == 0           /* no DOS error */
  568.      setText(self, appName(self) + ": " + fileName);
  569.     storeOn(project, file, nil);           /* write to file */
  570.     close(file);
  571.     dirty := false;
  572.   else
  573.     fileName := nil;                       /* due to DOS error */
  574.   endif;
  575.   showOldCurs();
  576. }!!
  577.  
  578. /* Print a text summary of the project.
  579.    Uses the Printer class.  */
  580. Def print(self | prn)
  581. {
  582.   prn := new(Printer);
  583.   showWaitCurs();                              /* takes a while */
  584.   if start(prn, "Project", self)               /* start printing */
  585.      do(getInfoLines(project),
  586.        {using(line)
  587.         printLine(prn, line);
  588.      });
  589.      printLine(prn, " ");
  590.      printLine(prn, " ");
  591.      printLine(prn, loadString(PW_ACTIVT1)+":");
  592.      printLine(prn, loadString(PW_ACTIVT2));
  593.      printLine(prn, loadString(PW_ACTIVT3));
  594.      printLine(prn, "--------------------------------------------");
  595.      do(sortedActivities(project),
  596.        {using(aNode)
  597.         printLine(prn, getInfoLine(aNode));
  598.      });
  599.      if size(resources(project)) > 0
  600.        printLine(prn, " ");
  601.        printLine(prn, " ");
  602.        printLine(prn, loadString(PW_REST1) + ":");
  603.        printLine(prn, loadString(PW_REST2));
  604.        printLine(prn, loadString(PW_REST3));
  605.        printLine(prn, "------------------------------------------");
  606.        do(resources(project),
  607.          {using(aRes)
  608.           printLine(prn, getInfoLine(aRes));
  609.        });
  610.      endif;
  611.      finish(prn);                             /* all done */
  612.      showOldCurs();
  613.   else
  614.     showOldCurs();
  615.     beep();
  616.     errorBox(loadString(PW_PRINTERR1),loadString(PW_PRINTERR2));
  617.   endif;
  618. }!!
  619.  
  620. /* Print graphics charts */
  621. Def printGraphs(self)
  622. {
  623.   printWindow(self, 1);
  624. }!!
  625.  
  626. /* Copy bitmap to clipboard */
  627. Def clipChart(self)
  628. {
  629.   clipWindow(self, 1);
  630. }
  631.  
  632. /* Create a new Milestone */
  633. Def newMilestone(self)
  634. {
  635.   newActivity(self, Milestone);
  636. }!!
  637.  
  638. /* Create a new Task */
  639. Def newTask(self)
  640. {
  641.   newActivity(self, Task);
  642. }!!
  643.  
  644. /* Create a new PERTTask */
  645. Def newPERTTask(self)
  646. {
  647.   newActivity(self, PERTTask);
  648. }!!
  649.  
  650. /* Create a new activity based on a menu choice. 
  651.    The nodeClass should be passed in as Task, Milestone etc.
  652.    Return the new activity or nil if canceled. */
  653. Def newActivity(self, nodeClass | activity)
  654. {  
  655.   activity := new(nodeClass);
  656.   setNetwork(activity, project);
  657.   if editInfo(activity) == IDOK   /* let user connect it */
  658.     if pos(activity) = 0@0        /* still not connected */
  659.       activity.y := 1;            /* safe location */
  660.       resetPosn(getNetwork(activity), activity, 0@0);
  661.     endif;
  662.     dirty(self);                  /* redraw etc. */
  663.     ^activity;
  664.   endif;
  665.   ^nil;
  666. }!!
  667.  
  668. /* Delete a resource in response to menu choice. 
  669.    Returns the deleted resource or nil if canceled. */
  670. Def deleteResource(self | dlg, name, res)
  671. { 
  672.   dlg := new(InputDialog, loadString(PW_DELRES1),
  673.       loadString(PW_DELRES2), "");
  674.   if runModal(dlg, INPUT_BOX, self) == IDOK
  675.     name := getText(dlg);
  676.     if res := checkResExists(project, name) 
  677.        delete(res, project);
  678.        dirty(self);
  679.        ^res;
  680.     endif;    
  681.   endif;
  682.   ^nil;
  683. }!!
  684.  
  685. /* Delete an activity in response to menu choice. 
  686.    Returns the deleted node or nil if canceled. */
  687. Def deleteActivity(self | dlg, name, node)
  688. { 
  689.   dlg := new(InputDialog, loadString(PW_DELACT1),
  690.       loadString(PW_DELACT2), "");
  691.   if runModal(dlg, INPUT_BOX, self) == IDOK
  692.     name := getText(dlg);
  693.     if node := checkNodeExists(project, name) 
  694.        delete(node);
  695.        dirty(self);
  696.        ^node;
  697.     endif;
  698.   endif;
  699.   ^nil
  700. }!!
  701.  
  702. /* Edit a particular resource in response to menu choice.
  703.    For now, ask the user which one. Return the resource
  704.    or nil if canceled. */
  705. Def editResource(self | dlg, res)
  706. {
  707.  dlg := new(InputDialog, loadString(PW_VIEWRES1), loadString(PW_VIEWRES2),"");
  708.  if runModal(dlg, INPUT_BOX, self) == IDOK
  709.    if res := checkResExists(project, getText(dlg))
  710.       editInfo(res);
  711.       dirty(self);
  712.       ^res;
  713.    endif;
  714.  endif;  
  715.  ^nil;
  716. }!!
  717.  
  718. /* Show all of the resources as in a TextWindow. */
  719. Def showResources(self | tw)
  720. {
  721.   tw := new(TextWindow, self, nil, loadString(PW_REST1), nil);
  722.   show(tw, 1);  
  723.   printLine(tw, loadString(PW_SHOWRES2));
  724.   printLine(tw, "-----------------------------------------------");
  725.   do(resources(project),
  726.     {using(res)  
  727.      printLine(tw, getInfoLine(res));
  728.   });
  729. }!!
  730.  
  731. /* Show all of the activities in a TextWindow. */
  732. Def showActivities(self | tw)
  733. {
  734.   tw := new(TextWindow, self, nil, loadString(PW_ACTIVT1), nil);
  735.   show(tw, 1);  
  736.   printLine(tw, loadString(PW_SHOWACT2));
  737.   printLine(tw, "------------------------------------------");
  738.   do(sortedActivities(project),
  739.     {using(aNode)  
  740.      printLine(tw, getInfoLine(aNode));
  741.   });
  742. }!!
  743.  
  744. /* Respond to menu choice to edit the project */
  745. Def viewSummary(self)
  746. {
  747.   editInfo(project);
  748. }!!
  749.  
  750. /* If the user presses the home key, reset scroll posn. */
  751. Def home(self)
  752. {
  753.   hScrollPos := vScrollPos := 0;
  754.   Call SetScrollPos(hWnd, SB_HORZ, hScrollPos, 1);
  755.   Call SetScrollPos(hWnd, SB_VERT, vScrollPos, 1);
  756.   invalidate(self);
  757. }!!
  758.  
  759. /* If the right button is pressed, toggle the view
  760.    to allow zoom in and out */
  761. Def zoom(self)
  762. {
  763.    if view == #normal
  764.         setView(self, #small);
  765.    else
  766.         setView(self, #normal);
  767.    endif;
  768.    invalidate(self);
  769. }!!
  770.  
  771. /* Show the amount of memory available. */
  772. Def showRoom(self | temp)
  773. { 
  774.  temp := Call GlobalCompact(Call GlobalCompact(0)+16) / 1024;
  775.  
  776.  errorBox(loadString(PW_SHOWROOM1),
  777.    asString(temp) + loadString(PW_SHOWROOM2));
  778. }!!
  779.  
  780. /* Respond to menu choice to recalculate. */
  781. Def recalc(self)
  782. {
  783.   showWaitCurs();
  784.   recalc(project);
  785.   invalidate(self);
  786.   if gw
  787.    invalidate(gw);
  788.   endif;
  789.   showOldCurs();
  790. }!!
  791.  
  792. /* The ganttWindow has closed.  */
  793. Def closeGantt(self)
  794. {
  795.   gw := nil;
  796.   enableMenuItem(self, PW_VIEW_GANTT);
  797. }!!
  798.  
  799. /* Respond to menu choice to set display options.  The user
  800.    can select information to be displayed above or below
  801.    the nodes in the window.  */
  802. Def displaySettings(self | dlg)
  803. {
  804.   dlg := new(PWSetDialog);
  805.   if runModal(dlg, SETTING_BOX, self) == IDOK
  806.      invalidate(self);
  807.   endif;
  808. }!!
  809.  
  810. /* Handle menu choice to create a Gantt chart. 
  811.    Create the window large enough to hold all of
  812.    the activities, plus some extra space. */
  813. Def gantt(self | height)
  814. {
  815.   if screenSize()=640@200
  816.     height := 10
  817.   else
  818.     height := 20;
  819.   endif;
  820.   gw := new(GanttWindow, self, nil, loadString(PW_GANTT),
  821.             rect(asInt(x(screenSize())/3), 
  822.               max(y(screenSize())-(size(project)+5)*height,10),
  823.               x(screenSize()), y(screenSize())));
  824.   setProject(gw, project);
  825.   show(gw,1);
  826.   grayMenuItem(self, PW_VIEW_GANTT);
  827. }!!
  828.  
  829. /* Display help information from resource file. */
  830. Def help(self | dlg)
  831. {
  832.   dlg := new(Dialog);
  833.   checkRunModal(dlg, PW_HELP_BOX, self);
  834. }!!
  835.  
  836. /* Display Actor information from resource file. */
  837. Def aboutActor(self | dlg)
  838. {
  839.   dlg := new(Dialog);
  840.   checkRunModal(dlg, PW_ABOUT_ACTOR_BOX, self);
  841. }!!
  842.  
  843. /* Handles menu choice to set autocalc. */
  844. Def autoCalc(self)
  845. {
  846.   if autoCalc(project)
  847.     unCheckMenuItem(self, PW_AUTOCALC);
  848.     setAutoCalc(project, false);
  849.   else
  850.     checkMenuItem(self, PW_AUTOCALC);
  851.     setAutoCalc(project, true);
  852.     recalc(self);
  853.   endif;
  854. }!!
  855.  
  856. /* See if the user has double clicked on a box.
  857.    If so, bring up a dialog for editing. Return the
  858.    activity or nil if canceled. */
  859. Def WM_LBUTTONDBLCLK(self, wp, lp | dPoint, activity)
  860. {
  861.   dPoint := windowToDisplay(self, asPoint(lp));
  862.   activity := displayLookup(project, dPoint);
  863.   if activity                       /* logically true if found */
  864.     if editInfo(activity) == IDOK   /* user clicked on activity */
  865.       dirty(self);                  /* changes were made */
  866.       ^activity;
  867.     endif;
  868.   else                              /* false if nothing found */
  869.     beep();                         /* user clicked on dead space */
  870.   endif;
  871.   ^nil;
  872. }!!
  873.  
  874. /* If the right button is pressed, toggle the view
  875.    to allow zoom in and out */
  876. Def WM_RBUTTONDOWN(self, wp, lp)
  877. {
  878.   zoom(self);
  879. }!!
  880.  
  881. /* Trap keyboard events to simulate mouse. Cursor keys move
  882.    the cursor and scroll, return and F2 edit an activity.
  883.    Note anything defined as an accelerator will NOT cause
  884.    a WM_KEYDOWN message.  The keys W, X, A, D can also be 
  885.    used to move the cursor. */
  886. Def WM_KEYDOWN(self, wp, lp | pos, x, y, activity, max, dict)
  887. { 
  888.   pos := getCursorPos(self);    /* client coords */
  889.   x := x(pos);
  890.   y := y(pos);
  891.  
  892.   select
  893.     case wp == VK_UP or wp == asInt('W')
  894.       y := y - boxHeight*2;
  895.     endCase
  896.     case wp == VK_DOWN or wp == asInt('X')
  897.       y := y + boxHeight*2;
  898.     endCase
  899.     case wp == VK_LEFT or wp == asInt('A')
  900.       x := x - activWidth;
  901.     endCase
  902.     case wp == VK_RIGHT or wp == asInt('D')
  903.       x := x + activWidth;
  904.     endCase
  905.     case wp == VK_RETURN or wp == VK_F2  
  906.       WM_LBUTTONDBLCLK(self, 1, asLong(pos));
  907.     endCase    
  908.   endSelect;
  909.   
  910.  /* If the cursor is moving off screen, scroll. */
  911.   
  912.   select
  913.     case y < 0 
  914.       y := boxHeight;
  915.       WM_VSCROLL(self, SB_LINEUP, 1);
  916.     endCase
  917.     case y > max:=maxVisRow*boxHeight*2
  918.       y := max - boxHeight;
  919.       WM_VSCROLL(self, SB_LINEDOWN, 1);
  920.     endCase
  921.   endSelect;
  922.   
  923.   select
  924.     case x < 0 
  925.       x := boxHSpace;
  926.       WM_HSCROLL(self, SB_LINEUP, 1);
  927.     endCase
  928.     case x > max:=maxVisCol*activWidth
  929.       x := max - boxWidth;
  930.       WM_HSCROLL(self, SB_LINEDOWN, 1);
  931.     endCase
  932.   endSelect;
  933.  
  934.   setCursorPos(self, point(x,y));
  935. }!!
  936.  
  937. /* Trap scrolling.  Adjust as necesary.
  938.    The wp is the scroll code, the lp gives posn. */
  939. Def WM_HSCROLL(self, wp, lp | scroll)
  940. { 
  941.   select
  942.     case wp == SB_LINEUP 
  943.        scroll := -1;
  944.     endCase
  945.     case wp == SB_LINEDOWN 
  946.        scroll := 1;
  947.     endCase
  948.     case wp == SB_PAGEUP
  949.        scroll := negate(maxVisCol);
  950.     endCase;
  951.     case wp == SB_PAGEDOWN
  952.        scroll := maxVisCol;
  953.     endCase;
  954.     case wp == SB_THUMBPOSITION
  955.        hScrollPos := 0; scroll := low(lp);
  956.     endCase;
  957.     default
  958.        scroll := nil;
  959.   endSelect;
  960.  
  961.   if scroll 
  962.     hScrollPos := hScrollPos + scroll;    /* adjust */
  963.     hScrollPos := min(PW_MAX_COLS, max(0, hScrollPos));
  964.     Call SetScrollPos(hWnd, SB_HORZ, hScrollPos, 1);
  965.     invalidate(self);
  966.   endif;
  967. }!!
  968.  
  969. /* Trap scrolling.  Adjust as necesary.
  970.    The wp is the scroll code, the lp gives posn. */
  971. Def WM_VSCROLL(self, wp, lp | scroll)
  972. { 
  973.   select
  974.     case wp == SB_LINEUP 
  975.        scroll := -1;
  976.     endCase
  977.     case wp == SB_LINEDOWN 
  978.        scroll := 1;
  979.     endCase
  980.     case wp == SB_PAGEUP
  981.        scroll := negate(maxVisRow);
  982.     endCase;
  983.     case wp == SB_PAGEDOWN
  984.        scroll := maxVisRow;
  985.     endCase;
  986.     case wp == SB_THUMBPOSITION
  987.        vScrollPos := 0; scroll := low(lp);
  988.     endCase;
  989.   endSelect;
  990.  
  991.   if scroll
  992.     vScrollPos := vScrollPos + scroll;    /* adjust */
  993.     vScrollPos := min(PW_MAX_ROWS, max(0, vScrollPos));
  994.     Call SetScrollPos(hWnd, SB_VERT, vScrollPos, 1);
  995.     invalidate(self);
  996.   endif;
  997. }!!
  998.  
  999.  
  1000. /* Begin dragging to allow the user to draw a line
  1001.    that will connect two boxes.  Setup the anchorPt and
  1002.    dragDC to allow dragging to do the drawing.
  1003.    BW 02/05/89 */
  1004. Def beginDrag(self, wp, aPt | dPoint, activity, dMode)
  1005. {
  1006.   dPoint := windowToDisplay(self, aPt);
  1007.   activity := displayLookup(project, dPoint);
  1008.   if activity   /* logically true if found */
  1009.     anchorPt := aPt;
  1010.     dragDC := getContext(self);
  1011.     dMode := Call SetROP2(dragDC,7);
  1012.     Call SelectObject(dragDC,Call GetStockObject(6));
  1013.   endif;
  1014. }!!
  1015.  
  1016. /* Do the drag and draw the feedback.
  1017.    BW 02/05/89 */
  1018. Def drag(self, wp, aPt )
  1019. { if dragDC then
  1020.     if oldPt cand (oldPt <> aPt)
  1021.       then moveTo(anchorPt,dragDC);
  1022.         lineTo(oldPt,dragDC);
  1023.     endif;
  1024.     oldPt := aPt;
  1025.     moveTo(anchorPt,dragDC);
  1026.     lineTo(aPt,dragDC);
  1027.   endif;
  1028. }!!
  1029.  
  1030. /* Finish the drag connection of two tasks.
  1031.    Create a new task if necessary. */
  1032. Def endDrag(self, wp, aPt | dPoint1, dPoint2, activity1, activity2)
  1033. {
  1034.   if dragDC then
  1035.     dPoint2 := windowToDisplay(self, aPt);
  1036.     activity2 := displayLookup(project, dPoint2);
  1037.     if activity2  /* logically true if found */
  1038.       dPoint1 := windowToDisplay(self,anchorPt);
  1039.       activity1 := displayLookup(project, dPoint1);
  1040.       if activity1 <> activity2
  1041.         connect(project,getName(activity1),
  1042.           getName(activity2));
  1043.         invalidate(self);
  1044.       endif;
  1045.     else /* maybe the user wants a new node */
  1046.       if activity2 := newActivity(self,Task) then
  1047.         dPoint1 := windowToDisplay(self,anchorPt);
  1048.         activity1 := displayLookup(project, dPoint1);
  1049.         connect(project,getName(activity1),
  1050.           getName(activity2));
  1051.         invalidate(self);
  1052.       else
  1053.         moveTo(anchorPt,dragDC); /* erase last line*/
  1054.         lineTo(oldPt,dragDC);
  1055.       endif;
  1056.     endif;
  1057.     releaseContext(self,dragDC); /* done drawing */
  1058.     dragDC := nil;
  1059.     oldPt := nil;
  1060.   endif;
  1061. }!!
  1062.  
  1063.