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