home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 396.lha / 'Liner_v2.0 / Source / Windows.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-07-04  |  17.0 KB  |  603 lines
  1. /*Windows.c -- Includes all routines that access the stuff in Windows.h*/
  2.  
  3. extern struct MenuItem *ItemAddress();
  4.  
  5. #include "Globals.h"
  6. #include "Windows.h"
  7.  
  8. #define ABOUT_Y_REG 42
  9. #define ABOUT_Y_LACED 142
  10.  
  11. void OpenGraphics() /*Open screen, window, etc.*/
  12. {
  13.    /*Open screen*/
  14.    NewWindow.Screen=Screen=(struct Screen *)OpenScreen(&NewScreen);
  15.    if(Screen==NULL)
  16.       Leave(50,"Can't open screen!!");
  17.  
  18.    LoadColors(&(Screen->ViewPort)); /*Set screen colors to those in prefs*/
  19.  
  20.    /*Open backdrop window & make requestors open onto it*/
  21.    if((ThisProc->pr_WindowPtr=Window=
  22.          (struct Window *)OpenWindow(&NewWindow))==NULL)
  23.       {
  24.       CloseScreen(Screen);
  25.       Leave(60,"Can't open Window!");
  26.       }
  27.    /*Install menus*/
  28.    SetMenuStrip(Window,&Menu1);
  29.  
  30.    /*Setup the console.device*/
  31.    consoleWritePort=(struct Port *)CreatePort("mycon.write",0);
  32.    if(consoleWritePort==NULL)
  33.       Leave(70,"Couldn't open console.device!");
  34.  
  35.    consoleWriteMsg=(struct IOStdReq *)CreateStdIO(consoleWritePort);
  36.    if(consoleWriteMsg==NULL)
  37.       Leave(80,"Couldn't open console.device!");
  38.  
  39.    consoleReadPort=(struct Port *)CreatePort("mycon.read",0);
  40.    if(consoleReadPort==NULL)
  41.       Leave(90,"Can't create communications port!");
  42.  
  43.    consoleReadMsg=(struct IOStdReq *)CreateStdIO(consoleReadPort);
  44.    if(consoleReadMsg==NULL)
  45.       Leave(100,"Can't create standard IO!");
  46.  
  47.    consoleWriteMsg->io_Data=(struct Window *)Window;  /*Attach console*/
  48.    consoleWriteMsg->io_Length=sizeof(struct Window);  /*device to window...*/
  49.    OpenDevice("console.device",0,consoleWriteMsg,0); /*& open it*/
  50.  
  51.    ConsoleDevice=consoleReadMsg->io_Device=(APTR)consoleWriteMsg->io_Device;
  52.    consoleReadMsg->io_Unit=consoleWriteMsg->io_Unit; /*Get the current keymap*/
  53.    consoleReadMsg->io_Command=CD_ASKKEYMAP;
  54.    consoleReadMsg->io_Length=sizeof(struct KeyMap);
  55.    consoleReadMsg->io_Data=&keymap;
  56.    DoIO(consoleReadMsg);
  57.    TitleErrorCancel();
  58. }
  59.  
  60. void CloseGraphics()   /*Close the window, screen, etc.*/
  61. {
  62.    CloseDevice(consoleWriteMsg);
  63.    DeleteStdIO(consoleWriteMsg);
  64.    DeleteStdIO(consoleReadMsg);
  65.    DeletePort(consoleWritePort);
  66.    DeletePort(consoleReadPort);
  67.    ClearMenuStrip(Window);
  68.    CloseWindow(Window);
  69.    CloseScreen(Screen);
  70. }
  71.  
  72. /*This is in liner.c and not menu.c because it needs to manipulate the*/
  73. /*'Liner NewScreen and NewWindow information, which it can't do from*/
  74. /*menu.c*/
  75.  
  76. void ChangeDisplay()
  77. {
  78.    UBYTE X,Y;
  79.    BOOL stat1,stat2,stat3,stat4;
  80.    
  81.    
  82.    X=CurX;
  83.    Y=CurY;
  84.    
  85.    stat1=HandleInterlaced();
  86.    stat2=SwapScrnSize();
  87.    stat3=DoubleSpacing();
  88.    stat4=HandleStartingLevel();
  89.    
  90.    if( stat1 || stat2 )
  91.    {
  92.       if( stat3 || stat4 )
  93.          CheckModified();
  94.  
  95.       CloseGraphics();
  96.       OpenGraphics();
  97.       
  98.       SetRowsInScreen();
  99.       PrintItemList(FirstScrnItem,1);
  100.       
  101.       if( !stat3 )
  102.       {
  103.          if(Y > DispRows)  /*if the old laced Y is > the current possible rows*/
  104.          {
  105.             Y=DispRows;    /*Y now = the last screen item*/
  106.             CurrentItem=(struct LineItem *)ScrnBtm;
  107.          }
  108.          if(X > MaxX(CurrentItem))  /*Out of bounds*/
  109.             X=MaxX(CurrentItem);
  110.          else if(X < MinX(CurrentItem))
  111.             X=MinX(CurrentItem);
  112.  
  113.          PlotCursor(X,Y);     /*Restore cursor position*/
  114.       }
  115.       else
  116.       {
  117.          CurrentItem=(struct LineItem *)FirstScrnItem;
  118.          PlotCursor(MinX(FirstScrnItem),1);
  119.       }
  120.    }
  121.    else
  122.       if( stat3 || stat4 )
  123.       {
  124.          SetRowsInScreen();
  125.          PrintItemList(FirstScrnItem,1);
  126.          if( !stat3 )
  127.          {
  128.             if(Y > DispRows)  /*if the old laced Y is > the current possible rows*/
  129.             {
  130.                Y=DispRows;    /*Y now = the last screen item*/
  131.                CurrentItem=(struct LineItem *)ScrnBtm;
  132.             }
  133.             if(X > MaxX(CurrentItem))  /*Out of bounds*/
  134.                X=MaxX(CurrentItem);
  135.             else if(X < MinX(CurrentItem))
  136.                X=MinX(CurrentItem);
  137.  
  138.             PlotCursor(X,Y);     /*Restore cursor position*/
  139.          }
  140.          else
  141.          {
  142.             CurrentItem=(struct LineItem *)FirstScrnItem;
  143.             PlotCursor(MinX(FirstScrnItem),1);
  144.             CheckModified();
  145.          }
  146.       }
  147. }         
  148.  
  149. BOOL HandleStartingLevel() /*Change the starting level*/
  150. {
  151.    BYTE c;
  152.    
  153.    for(c=0;c<6 && (SubItems[c]->Flags & CHECKED) != CHECKED;c++);
  154.    if(c==6)
  155.    {
  156.       c=0;
  157.       SubItems[0]->Flags |= CHECKED;
  158.    }
  159.    
  160.    if(c!=StartingLevel)
  161.    {
  162.       StartingLevel=c;
  163.       return(TRUE);
  164.    }
  165.    
  166.    return(FALSE);
  167. }
  168.  
  169. BOOL DoubleSpacing() /*Toggle between single & double spacing*/
  170. {
  171.    if(prefs.DS==(( DOUBSPAC_MI.Flags & CHECKED)==CHECKED))
  172.       return(FALSE);
  173.    prefs.DS=!prefs.DS;
  174.    return(TRUE);
  175. }
  176.    
  177.  
  178. BOOL HandleInterlaced()   /*Toggle between a normal and interlaced screen*/
  179. {
  180.    
  181.    if(prefs.Laced == ((INTERLACE_MI.Flags & CHECKED) == CHECKED))
  182.       return(FALSE);
  183.  
  184.    if(prefs.Laced)   /*If interlaced*/
  185.       {
  186.       NewScreen.Height/=2;
  187.       NewWindow.Height=NewScreen.Height-11;
  188.       NewScreen.ViewModes=HIRES; /*Remove LACE from screen description*/
  189.       prefs.Laced=FALSE;         /*Status switch*/
  190.       }
  191.    else  /*not interlaced*/
  192.       {
  193.       NewScreen.Height*=2;
  194.       NewWindow.Height=(NewScreen.Height-11);
  195.       NewScreen.ViewModes=HIRES+LACE; /*Add LACE to screen description*/
  196.       prefs.Laced=TRUE;
  197.       }
  198.    return(TRUE);
  199. }
  200.  
  201. BOOL SwapScrnSize() /*Change a standard sized screen to Workbench sized & back*/
  202. {
  203.  
  204.    UBYTE X,Y;
  205.    BYTE stat;
  206.    X=CurX;
  207.    Y=CurY;  /*Store cursor position*/
  208.  
  209.    
  210.    stat = FALSE;
  211.    if(((WBENCH_SI.Flags & CHECKED) == CHECKED) && prefs.Screen==0)
  212.    {
  213.       prefs.Screen = 1;  /*Switch to Workbench sized screen*/
  214.       NewScreen.Height=GetWBHeight(); /*Get height of Workbench screen*/
  215.       if(NewScreen.Height > 300) /*Prob. interlaced*/
  216.          NewScreen.Height /= 2;  /*Cut it down*/
  217.       stat=TRUE;
  218.    }
  219.    
  220.    if(((STANDARD_SI.Flags & CHECKED) == CHECKED) && prefs.Screen == 1)
  221.    {
  222.       prefs.Screen = 0;  /*Switch to standard screen*/
  223.       NewScreen.Height=200;
  224.       stat=TRUE;
  225.    }
  226.  
  227.    if(!stat)
  228.       return(FALSE);;
  229.       
  230.    if(prefs.Laced)
  231.       NewScreen.Height*=2;
  232.    
  233.    NewWindow.Height=NewScreen.Height-11; /*'Liner's window is always 11*/
  234.          /*lines shorter than the host screen*/
  235.    
  236.    return(TRUE);
  237. }
  238.  
  239. void ModifyMenus(Flag)/*Modify Double Spacing and Starting Level menus for the*/
  240. char Flag;            /*ReadItemList function*/
  241. {
  242.    if(Flag>=32)   /*If double spaced...*/
  243.       {
  244.       prefs.DS=TRUE;
  245.       MenuItem1.Flags=CHECKIT+ITEMTEXT+COMMSEQ+MENUTOGGLE+
  246.             ITEMENABLED+HIGHCOMP+CHECKED;
  247.       Flag-=32;  /*Removed double spacing flag*/
  248.       }
  249.    else
  250.       {
  251.       prefs.DS=FALSE;
  252.       MenuItem1.Flags=CHECKIT+ITEMTEXT+COMMSEQ+MENUTOGGLE+
  253.          ITEMENABLED+HIGHCOMP;
  254.       }
  255.  
  256.    SubItems[StartingLevel]->Flags-=CHECKED;
  257.    StartingLevel=(Flag <= 5) ? Flag : 5;
  258.    SubItems[StartingLevel]->Flags+=CHECKED;
  259. }
  260.  
  261. void GetLinerPrefs(filename)
  262. char *filename;
  263. {
  264.    struct FileHandle *fp;
  265.    
  266.    if((fp=(struct FileHandle *)Open(filename,MODE_OLDFILE))==NULL)
  267.       return;             /*If no preferences file could be found*/
  268.                           /*use the defaults*/
  269.  
  270.    Read(fp,&prefs,sizeof(struct LinerPrefs));  /*Read in the preferences*/
  271.    Close(fp);        /*Close the file*/
  272. }
  273.  
  274. void InterpretPrefs()   /*Install the preferences*/
  275. {
  276.    StartingLevel = 0;
  277.    SubItems[StartingLevel]->Flags+=CHECKED;
  278.    ModifyMenus(prefs.Level+((prefs.DS) ? 32 : 0)); /*Double spacing and*/
  279.                                                    /*starting level*/
  280.                                                    
  281.    if(prefs.Icons)
  282.       MenuItem3.Flags+=CHECKED;
  283.  
  284.    if(prefs.Screen == 0) /*Standard screen*/
  285.    {
  286.       SubItem1.Flags+=CHECKED;
  287.       NewScreen.Height=200;
  288.    }
  289.    else /*Workbench screen*/
  290.    {
  291.       SubItem2.Flags+=CHECKED;
  292.       NewScreen.Height=GetWBHeight(); /*Get the Workbench height*/
  293.       if(NewScreen.Height > 300) /*Then it's interlaced*/
  294.          NewScreen.Height/=2;    /*so cut it in half*/
  295.    }         
  296.  
  297.    NewScreen.ViewModes=HIRES;
  298.    if(prefs.Laced)
  299.    {
  300.       NewScreen.Height*=2;   /*Double the screen size*/
  301.       NewScreen.ViewModes+=LACE;
  302.       MenuItem2.Flags+=CHECKED;
  303.    }
  304.    else
  305.       NewScreen.ViewModes=HIRES;
  306.    
  307.    NewWindow.Height=NewScreen.Height-11;
  308.  
  309.    prefs.Name[0][12]=NULL; /*Make sure none of the name >12 characters*/
  310.    prefs.Name[1][12]=NULL;
  311.    prefs.Name[2][12]=NULL;
  312.    prefs.Name[3][12]=NULL;
  313.    CopyPrefsToMenus();
  314.    
  315.    strcpy(SDirName,prefs.DefaultDir); /*Get the default disk directories*/
  316.    strcpy(PDirName,prefs.DefPrintDir);
  317.    
  318.    strcpy(SExt,prefs.DefPattern);   /*And the default filepattern*/
  319.    
  320.    OpenGraphics();      /*And open the screen, window, etc...*/
  321.    SetRowsInScreen();
  322. }
  323.  
  324. PutPrefs(filename,AREXX)      /*Save the preferences to disk*/
  325. char *filename;
  326. BYTE AREXX;
  327. {
  328.    struct FileHandle *fp;
  329.    
  330.    if((fp=(struct FileHandle *)Open(filename,MODE_NEWFILE))==NULL)
  331.    {
  332.       if(!AREXX)
  333.          TitleError("Couldn't save the preferences!");
  334.       return(FALSE);
  335.    }
  336.  
  337.    strcpy(prefs.Name[0],IText21.IText);   /*Copy ARexx macro info*/
  338.    strcpy(prefs.Name[1],IText20.IText);
  339.    strcpy(prefs.Name[2],IText19.IText);
  340.    strcpy(prefs.Name[3],IText18.IText);
  341.    
  342.    strcpy(prefs.DefaultDir,SDirName);
  343.    strcpy(prefs.DefPrintDir,PDirName);
  344.    strcpy(prefs.DefPattern,SExt);
  345.    
  346.    prefs.Level=StartingLevel;
  347.    
  348.    
  349.    Write(fp,&prefs,sizeof(struct LinerPrefs));
  350.    Close(fp);  /*Done*/
  351.    CreatePrefsIcon();   /*Make the icon for liner.prefs*/
  352.    return(TRUE);
  353. }
  354.  
  355. void CopyPrefsToMenus()
  356. {
  357.    strcpy(IText21.IText,prefs.Name[0]); /*Copy ARexx info to the menus*/
  358.    strcpy(IText20.IText,prefs.Name[1]);
  359.    strcpy(IText19.IText,prefs.Name[2]);
  360.    strcpy(IText18.IText,prefs.Name[3]);
  361. }
  362.  
  363. GetWBHeight()     /*Get the height of the Workbench screen*/
  364. {
  365.    int height;
  366.    ULONG ILock;
  367.    struct Screen *s;
  368.    
  369.    ILock=LockIBase(0);  /*Lock IntuitionBase while I find the WB screen size*/
  370.    
  371.    s=(struct Screen *)IntuitionBase->FirstScreen;
  372.    while( (s != NULL) && ((s->Flags & CUSTOMSCREEN) == CUSTOMSCREEN) )
  373.       s=(struct Screen *)s->NextScreen; /*Search to end of list or first*/
  374.                            /*non CUSTOMSCREEN screen (ie WBENCHSCREEN)*/
  375.    if(s==NULL)    /*If not found, give a default height of 200*/
  376.       height=200;
  377.    else
  378.       height=s->Height;
  379.       
  380.    UnlockIBase(ILock); /*Unlock IntuitionBase*/
  381.    
  382.    return(height);      /*And we're done*/
  383. }
  384.  
  385. struct MenuItem *GetFirstItemAddress(code) /*Get a MenuItem associated*/
  386. USHORT code;   /*with the menu's number*/
  387. {
  388.    return(ItemAddress(&Menu1,code));
  389. }
  390.  
  391. void SaveColors(vp)  /*Save the screen's colors to prefs*/
  392. struct ViewPort *vp;
  393. {
  394.    ULONG c,rgb;
  395.    
  396.    for(c=0; c < 4 ; c++)   /*Get screen colors*/
  397.    {
  398.       rgb=GetRGB4(vp->ColorMap,c);
  399.  
  400.       prefs.Color[c][0]=(rgb >> 8) & 0xF;
  401.       prefs.Color[c][1]=(rgb >> 4) & 0xF;
  402.       prefs.Color[c][2]= rgb & 0xF;
  403.  
  404.    }
  405. }
  406.  
  407. void LoadColors(vp)  /*Change the screen colors to those in prefs*/
  408. struct ViewPort *vp;
  409. {
  410.    ULONG c;
  411.    
  412.    for(c=0; c < 4; c++)
  413.       SetRGB4(vp,c,prefs.Color[c][0],prefs.Color[c][1],prefs.Color[c][2]);
  414. }
  415.  
  416. void ClearMenus()/*Set the menus to state they are in when 'Liner is first run*/
  417. {
  418.    if(MenuItem3.Flags & CHECKED) /*Icons*/
  419.       MenuItem3.Flags-=CHECKED;
  420.       
  421.    if(SubItem1.Flags & CHECKED) /*Standard/Workbench screen*/
  422.       SubItem1.Flags-=CHECKED;
  423.    else
  424.       SubItem2.Flags-=CHECKED;
  425.    
  426.    ModifyMenus(0);   /*Set Double spacing and Starting level menus*/
  427.    
  428.    SubItems[StartingLevel]->Flags-=CHECKED;
  429.    
  430.    if(MenuItem2.Flags & CHECKED)
  431.       MenuItem2.Flags-=CHECKED;
  432. }
  433.  
  434. void SetRowsInScreen() /*Determine the # of text rows in a screen*/
  435. {
  436.    int temp;
  437.                   /*Divide the height of the window by the current font's*/
  438.    temp=(Window->Height)/Window->IFont->tf_YSize; /*height*/
  439.                         
  440.    if(prefs.DS)      /*If double spaced*/
  441.    {
  442.       RowsInScreen=(Window->Height)/(Window->IFont->tf_YSize*2);
  443.       if(temp != RowsInScreen*2) /*Needed to keep extra lines from showing*/
  444.          Odd=TRUE;               /*up in some circumstances*/
  445.       else
  446.          Odd=FALSE;
  447.    }
  448.    else
  449.       RowsInScreen=temp;
  450. }
  451.  
  452. void ModifyOtherMenus(menu) /*Change Interlaced, Icon, and screen size */
  453. BYTE menu;     /*menus where appropriate*/
  454. {
  455.    switch(menu)
  456.    {
  457.       case 1:  /*Interlaced menu*/
  458.          if(prefs.Laced)
  459.             MenuItem2.Flags-=CHECKED;
  460.          else
  461.             MenuItem2.Flags+=CHECKED;
  462.          break;
  463.          
  464.       case 2:  /*Icon creation*/
  465.          if(prefs.Icons)
  466.             MenuItem3.Flags-=CHECKED;
  467.          else
  468.             MenuItem3.Flags+=CHECKED;
  469.          break;
  470.          
  471.       case 3:  /*Screen size manipulation*/
  472.          if(prefs.Screen==0) /*Standard screen*/
  473.          {
  474.             SubItem2.Flags+=CHECKED;
  475.             SubItem1.Flags-=CHECKED;
  476.          }
  477.          else
  478.          {
  479.             SubItem2.Flags-=CHECKED;
  480.             SubItem1.Flags+=CHECKED;
  481.          }
  482.    }
  483. }
  484.  
  485. HandleAbout()  /*Displays the 'About' window*/
  486. {     /*It's here because it needs to access Windows.h*/
  487.    struct Window *AboutWdw;
  488.  
  489.    NewAboutWindow.Screen=Screen;    /*Pointer to window's screen*/
  490.  
  491.    if(prefs.Laced)
  492.       NewAboutWindow.TopEdge=ABOUT_Y_LACED;
  493.    else
  494.       NewAboutWindow.TopEdge=ABOUT_Y_REG;
  495.  
  496.    if((AboutWdw=(struct Window *)OpenWindow(&NewAboutWindow))==NULL)
  497.       return(FALSE);
  498.  
  499.    SetWindowTitles(AboutWdw,-1,"For your information...");
  500.    SetAPen(AboutWdw->RPort,1);
  501.    PrintIText(AboutWdw->RPort,&IntuiTextList2,0,0);
  502.  
  503.          /*Wait for the user to press the Continue... gadget*/
  504.    Wait(1<<AboutWdw->UserPort->mp_SigBit);
  505.  
  506.    CloseWindow(AboutWdw);     /*Close the window*/
  507. }
  508.  
  509. NewAll() /*Get rid of all the Items*/
  510. {
  511.    char Buffer[10];
  512.  
  513.    FreeListMem(FirstItem,LastItem);
  514.  
  515.    prefs.DS=FALSE;
  516.    SetRowsInScreen();
  517.    
  518.    ModifyMenus(0); /*Set menus (Double Spacing & Starting Level) to defaults*/
  519.    StartingLevel=0;
  520.    SubItems[0]->Flags|=CHECKED;
  521.  
  522.       /*Setup a fresh outline*/
  523.    FirstItem=LastItem=FirstScrnItem=ScrnBtm=CurrentItem=
  524.          (struct LineItem *)InsertItem(NULL,NULL);
  525.    if(FirstItem==NULL)
  526.    {
  527.       CloseGraphics();
  528.       CloseLibrary(IconBase);
  529.       CloseLibrary(DosBase);
  530.       Leave(1000,"Out of memory!");
  531.    }
  532.    
  533.    CurrentItem->Level=1;
  534.    Buffer[0]=0x0c;
  535.    WriteConsole(Buffer,1);
  536.    
  537.    Buffer[0]=CSI;
  538.    Buffer[1]='0';
  539.    Buffer[2]=0x6d;
  540.    
  541.    WriteConsole(Buffer,3); /*Cancel any highlighting*/
  542.    InvsMode=NOINV;
  543.    PrintItemList(CurrentItem,1);
  544.    PlotCursor(MinX(CurrentItem),CurY);
  545.    Modified=FALSE;
  546.    TitleErrorCancel();
  547.    MenuItem1.Flags=CHECKIT+ITEMTEXT+COMMSEQ+MENUTOGGLE+ITEMENABLED+HIGHCOMP;
  548.  
  549.    FileName[0]=NULL;     /*Remove default filenames*/
  550.    SFileName[0]=NULL;
  551.    PDName[0]=NULL;
  552.    PFileName[0]=NULL;
  553.    TitleErrorCancel();
  554.  
  555.    return(TRUE);
  556. }
  557.  
  558. void HandleIcons()
  559. {
  560.    prefs.Icons = ((ICON_MI.Flags & CHECKED)==CHECKED);
  561. }
  562.  
  563. void HandleEvent(object)
  564. APTR object;
  565. {
  566.   if (object == (APTR)&MenuItem21) { HandleNew(object); return; }
  567.   if (object == (APTR)&MenuItem22) { HandleOpen(FALSE); return; }
  568.   if (object == (APTR)&MenuItem23) { Save(FALSE); return; }
  569.   if (object == (APTR)&MenuItem24) { HandleSaveAs(FALSE); return; }
  570.   if (object == (APTR)&SubItem11) { HandlePrintPrinter(FALSE); return; }
  571.   if (object == (APTR)&SubItem12) { HandlePrintDisk(FALSE,""); return; }
  572.   if (object == (APTR)&MenuItem26) { HandleAbout(FALSE); return; }
  573.   if (object == (APTR)&MenuItem27) { HandleQuit(FALSE); return; }
  574.   if (object == (APTR)&MenuItem17) { HandleCut(FALSE); return; }
  575.   if (object == (APTR)&MenuItem18) { HandleCopy(FALSE); return; }
  576.   if (object == (APTR)&MenuItem19) { HandlePaste(FALSE); return; }
  577.   if (object == (APTR)&MenuItem20) { HandleErase(FALSE); return; }
  578.   if (object == (APTR)&MenuItem14) { DoSearch(FALSE,FALSE); return; }
  579.   if (object == (APTR)&MenuItem15) { DoSearch(TRUE,FALSE); return; }
  580.   if (object == (APTR)&MenuItem10) { EngageMacro(prefs.Macro[0]); return; }
  581.   if (object == (APTR)&MenuItem11) { EngageMacro(prefs.Macro[1]); return; }
  582.   if (object == (APTR)&MenuItem12) { EngageMacro(prefs.Macro[2]); return; }
  583.   if (object == (APTR)&MenuItem13) { EngageMacro(prefs.Macro[3]); return; }
  584.   if (object == (APTR)&MenuItem1) { ChangeDisplay(); return; }
  585.   if (object == (APTR)&MenuItem2) { ChangeDisplay(); return; }
  586.   if (object == (APTR)&MenuItem3) { HandleIcons(object); return; }
  587.   if (object == (APTR)&SubItem3) { ChangeDisplay(); return; }
  588.   if (object == (APTR)&SubItem4) { ChangeDisplay(); return; }
  589.   if (object == (APTR)&SubItem5) { ChangeDisplay(); return; }
  590.   if (object == (APTR)&SubItem6) { ChangeDisplay(); return; }
  591.   if (object == (APTR)&SubItem7) { ChangeDisplay(); return; }
  592.   if (object == (APTR)&SubItem8) { ChangeDisplay(); return; }
  593.   if (object == (APTR)&MenuItem5) { HandlePalette(object); return; }
  594.   if (object == (APTR)&SubItem1) { ChangeDisplay(); return; }
  595.   if (object == (APTR)&SubItem2) { ChangeDisplay(); return; }
  596.   if (object == (APTR)&MenuItem7) { GetMacroInfo(); return; }
  597.   if (object == (APTR)&MenuItem8) { HandleReloadPrefs(object); return; }
  598.   if (object == (APTR)&MenuItem9) { PutPrefs("liner:liner.prefs",FALSE);return;}
  599.   if (object == (APTR)&SubItem9) { ReplaceAll(TRUE); return; }
  600.   if (object == (APTR)&SubItem10) { ReplaceAll(FALSE); return; }
  601. }
  602.  
  603. /*End of Windows.c*/