Controlling the operation: Controller.oz

Source File

functor 
 
require 
 
   DemoUrls(image) at '../DemoUrls.ozf'  
 
prepare 
   ImageNames = [DemoUrls.image#'college/title.xbm']
 
import 
 
   Tk
   TkTools
   Application
 
   Scheduler(timeTable: TimeTable)
    
export 
 
   Controller
 
   TopWindow
 
define 
 
   TopWindow = {New Tk.toplevel tkInit(title:'College Time-Tabling' 
                                       delete: proc{$}
                                                  {TopWindow tkClose}
                                                  {Application.exit 0}
                                               end)}
    
    
   Images = {TkTools.images ImageNames}
 
   fun {Controller}
       
      Menu = {New Tk.frame
              tkInit(parent:TopWindow relief:raised borderwidth:2)}
      ControllerLabel = {New Tk.label tkInit(parent: Menu text: "")}
       
      {Tk.send pack(Menu side:top fill:x)}
       
      MB1 MB2 MB3
      M1 M2 M3
      AAbout AExit
       
      ALoadSolution
       
\ifndef ALONEDEMO 
      ASaveSolution  
      AEditProblem
      ALoadProblem
\endif 
    
      AFirstSol AOptimize
      AIntrOpt ADispGraphical ADispInspecting
      ADispTextual
    
      fun {TkAction What Parent P1 P2}
         {New Tk.action tkInit(parent: Parent
                               action: proc {$}
                                          if P2 == none then 
                                             {What P1}
                                          else 
                                             {What P1 P2}
                                          end 
                                       end)}
      end 
 
      proc {DoFileOp MessageName Flag}
         File
      in 
         if Flag == read then 
            {Tk.return tk_getOpenFile(title: 'Select file' 
                                      filetypes:  q(q('Data files' q('.ozt'))
                                                    q('Oz Files  ' q('.oz'))))
             File}
         else 
            {Tk.return tk_getSaveFile(title: 'Select file' 
                                      filetypes:  q(q('Data files' q('.ozt'))
                                                    q('Oz Files  ' q('.oz'))))
             File}
         end 
       
         {Wait File}
 
         if File == nil then skip 
         else        
            {ControllerLabel tk(configure text:"File "#Flag)}
            {TimeTable MessageName(File)}
         end 
      end 
 
\ifdef ALONEDEMO   
      proc {DoFileOpAlone MessageName Flag}
         {TimeTable MessageName(_)}
      end 
\endif 
    
   % -------------------------------------------------
    
      proc {About}
         AboutWindow = {New Tk.toplevel tkInit(parent:TopWindow)}
         OK = {New Tk.button
               tkInit(parent:AboutWindow text:'OK' relief:raised
                      borderwidth:2
                      action: AboutWindow # tkClose)}
         Message = {New Tk.message
                    tkInit(parent:AboutWindow
                           aspect:300  
                           relief:raised
                           borderwidth:1
                           font:'-misc-fixed-bold-*-*-*-*-*-*-*-*-*-*' 
                           text:
                              "This propgram allows to solve a time tabling problem. When started, a problem is already read in. Hence, just start solving. The search may be interrupted (if a solution was already computed) and resumed.\n")}
      in 
         {Tk.batch [wm(title AboutWindow "What is it?")
                    wm(iconname AboutWindow "About")
                    pack(Message side:top)
                    pack(OK side:bottom fill:x)]}
      end 
 
      % -------------------------------------------------
 
      {Tk.send pack(ControllerLabel side: right)}
 
      proc {Compute Message Display}
         {ControllerLabel tk(configure text: "Computing...")}
         {TimeTable Message}  
         thread 
            {Wait {TimeTable get($)}}
            {ControllerLabel tk(configure text: "done")}
            {TimeTable Display}
         end 
      end 
       
      % -------------------------------------------------
 
      TitleCanvas = {New Tk.canvas tkInit(parent: TopWindow
                                          height: 130 width: 340)}
      {TitleCanvas tk(crea image 0 0
                      image: Images.'title' 
                      anchor:nw)}
      {TitleCanvas tk(crea text 240 40
                      text:"TimeTable" anchor:nw
                      font:'-adobe-helvetica-bold-o-*-*-18-*')}
      {TitleCanvas tk(crea text 240 65
                      text:"Manager" anchor:nw
                      font:'-adobe-helvetica-bold-o-*-*-18-*')}
       
      {Tk.send pack(TitleCanvas side:top)}
 
   in 
 
      {ForAll [ [MB1 " File"] [MB2 " Compute"] [MB3 " Output"] ]
       proc {$ MB}
          MB.1 = {New Tk.menubutton tkInit(parent:Menu text:MB.2.1)}
       end}
       
      {ForAll [ [M1 MB1] [M2 MB2] [M3 MB3] ]
       proc {$ M} M.1 = {New Tk.menu tkInit(parent:M.2.1)} end}
 
      AAbout = {New Tk.action tkInit(parent: Menu action: About)}
      AExit = {New Tk.action tkInit(parent: Menu
                                    action: proc{$}
                                               {TopWindow tkClose}
                                               {Application.exit 0}
                                            end)}
       
      {ForAll [
\ifndef ALONEDEMO 
               [ALoadProblem DoFileOp readProblem read]
               [AEditProblem DoFileOp edit read]
               [ALoadSolution DoFileOp read read]
               [ASaveSolution DoFileOp save written]
\else 
               [_             DoFileOp readProblem read]
               [_             DoFileOp edit read]
               [ALoadSolution DoFileOpAlone read read]
\endif 
               [AFirstSol Compute solveProblem graphic]
               [AOptimize TimeTable optimizeProblem none]
               [AIntrOpt TimeTable anyTime none]
               [ADispGraphical TimeTable graphic none]
               [ADispInspecting TimeTable inspect none]
               [ADispTextual TimeTable text none]
              ]
       proc {$ Action}
          Action.1 = {TkAction Action.2.1 Menu Action.2.2.1 Action.2.2.2.1}
       end}
    
\ifndef ALONEDEMO 
      {ForAll [ ["  Load problem " ALoadProblem]
                ["  Edit problem " AEditProblem]
                ["--------------"]
                ["  Load solution " ALoadSolution]
                ["  Save Solution " ASaveSolution]
                ["--------------"]
                ["  Exit " AExit] ]
\else 
       {ForAll [ ["  Load solution " ALoadSolution]
                 ["--------------"]
                 ["  About this program " AAbout]
                 ["--------------"]
                 ["  Exit " AExit] ]
\endif        
        proc{$ C}
           case C.1
           of "--------------" then {M1 tk(add sep)}
           else {M1 tk(add command label: C.1 command: C.2.1)}
           end 
        end}
       {ForAll [ ["  First Solution " AFirstSol]
                 ["  Optimize Current Solution " AOptimize]
                 ["--------------"]
                 ["  Interrupt Solving " AIntrOpt] ]
        proc{$ C}
           case C.1
           of "--------------" then {M2 tk(add(sep))}
           else {M2 tk(add(command(label: C.1 command: C.2.1)))}
           end 
        end}
       {ForAll [ ["  Display graphically " ADispGraphical]
                 ["  Display with Inspector " ADispInspecting]
                 ["  Display textually " ADispTextual]
               ]
        proc{$ C}
           case C.1
           of "--------------" then {M3 tk(add(sep))}
           else {M3 tk(add command label: C.1 command: C.2.1)}
           end 
        end}
       
       {MB1 tk(conf menu: M1)}
       {MB2 tk(conf menu: M2)}
       {MB3 tk(conf menu: M3)}
 
       {Tk.send pack(MB1 MB2 MB3 side: left)}
       {Tk.send tk_menuBar(Menu MB1 MB2 MB3)}
 
       ControllerLabel       
   end 
       
end 


Version 1.4.0 (20080702)