home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 22 gnu / 22-gnu.zip / dlged002.zip / dlgedit.cpp < prev    next >
C/C++ Source or Header  |  1995-11-24  |  15KB  |  577 lines
  1. /* 
  2.  
  3.  
  4.     dlgedit.cpp (emx+gcc) 
  5.  
  6.     1994,95 Giovanni Iachello
  7.     This is freeware software. You can use or modify it as you wish,
  8.     provided that the part of code that I wrote remains freeware.
  9.     Freeware means that the source code must be available on request 
  10.     to anyone.
  11.     You must also include this notice in all files derived from this
  12.     file.
  13.  
  14.  
  15. */
  16.  
  17. #include <stdio.h>
  18. #include <string.h>
  19. #include <stdlib.h>
  20. #define INCL_WIN
  21. #define INCL_DOSFILEMGR
  22. #include "pmwin.h"
  23. #include "pmdlg.h"
  24. #include "pmgpi.h"
  25. #include "pmstdres.h"
  26. #include "dlgedit.h"
  27. #include "dlgdata.h"
  28.  
  29. PMApp* App;
  30.  
  31. LONG aveCharX,aveCharY;
  32.  
  33.  
  34.  
  35. /////////////////////////////////////////////////////////////////////////////
  36.  
  37.  
  38. WorkWindow::WorkWindow(HAB ab,_dlginfo* idlginfo,PMWin* ieditor) : PMWin("temporaryDLGEDITworkwindow",ab) {
  39.     dlginfo=idlginfo;
  40.     editor=ieditor;
  41.     
  42.     createArgs->hwndParent=editor->getHwnd();
  43.     dlginfo->makeflags();
  44.     createArgs->flCreateFlags=dlginfo->flags | FCF_SHELLPOSITION;
  45.     createArgs->pszTitle=dlginfo->title;
  46.  
  47.     mouseCaptured=FALSE;
  48.     ptr1= new PMPointer(PMPTR_1);
  49.     newControl=0;
  50. }
  51.  
  52. WorkWindow::~WorkWindow() 
  53. {
  54.     _dlgcontrol* p=dlginfo->dlgctrl;
  55.     while (p!=NULL) { // elimina i controlli
  56.         p->win->destroyWin();
  57.         p=p->next;
  58.     }
  59.     delete popup;
  60.     delete ptr1;
  61. }
  62.  
  63. BOOL WorkWindow::createWin()
  64. {
  65.     PMWin::createWin();
  66.     setFramePos(editor->getHwnd(),10,10,d2rx(dlginfo->sx),d2ry(dlginfo->sy),SWP_SIZE|SWP_MOVE);
  67.  
  68.     _dlgcontrol* p=dlginfo->dlgctrl;
  69.     while (p!=NULL) { // ricrea le finestre
  70.         p->win=new ControlWin(this,apszClasses[p->classidx],
  71.                 p->text, p->flags, d2rx(p->x), d2ry(p->y), d2rx(p->cx), d2ry(p->cy),
  72.                     HWND_BOTTOM, p->idl);
  73.         p->win->createWin();
  74.         p=p->next;
  75.     }
  76.     popup = new PMPopupMenu(this,IDM_POPUPMENU);
  77.     return hwnd;
  78. }
  79.  
  80. BOOL WorkWindow::paint()
  81. {
  82.     PMWindowPresSpace ps(this);
  83.     PMRect rcl;
  84.     rcl=this;
  85.     ps.fillRect(&rcl,CLR_PALEGRAY);
  86.     return TRUE;
  87. }
  88.  
  89. void WorkWindow::drawOutline()
  90. {
  91.     PMMicroCachedPresSpace ps(this);
  92.     ps.setMix(FM_INVERT);
  93.     ps.move(&start);
  94.     ps.box(DRO_OUTLINE,&end);
  95. }
  96.  
  97. void WorkWindow::addControl()
  98. {
  99.     _dlgcontrol* p; 
  100.     p=new _dlgcontrol;
  101.     p->text[0]=0;
  102.     p->x=r2dx(min(start.x,end.x));
  103.     p->y=r2dy(min(start.y,end.y));
  104.     p->cx=r2dx(abs(end.x-start.x));
  105.     p->cy=r2dy(abs(end.y-start.y));
  106.     p->idc[0]=0;
  107.     if (dlginfo->dlgctrl) p->idl=dlginfo->dlgctrl->idl+1; else p->idl=0;
  108.     p->classidx=menu2classindex[newControl];
  109.     p->flags=WS_VISIBLE|lClassesDefStyles[p->classidx];
  110.         
  111.     p->win=new ControlWin(this,apszClasses[p->classidx],
  112.                 p->text, p->flags, d2rx(p->x), d2ry(p->y), d2rx(p->cx), d2ry(p->cy),
  113.                 HWND_BOTTOM, p->idl);
  114.     p->win->createWin();
  115.  
  116.     p->next=dlginfo->dlgctrl;
  117.     dlginfo->dlgctrl=p;
  118.     editor->postMsg(WM_MODIFIED);            
  119. }
  120.  
  121. BOOL WorkWindow::mouse(PMEvent &event)
  122. {
  123.     if (newControl)
  124.     switch (event.msg) {
  125.         case WM_BUTTON1DOWN:
  126.             TRACKINFO track;
  127.  
  128.             track.cxBorder = 1;
  129.             track.cyBorder = 1;
  130.             track.cxGrid = 1;
  131.             track.cyGrid = 1;   
  132.             track.cxKeyboard = 4;
  133.             track.cyKeyboard = 4; 
  134.  
  135.             WinSetRect(ab, &track.rclTrack, event.mousemsg->x,event.mousemsg->y,event.mousemsg->x,event.mousemsg->y);   /* starting point */
  136.  
  137.             WinSetRect(ab, &track.rclBoundary, 0, 0, 640, 480); /* bounding rectangle */
  138.  
  139.             track.ptlMinTrackSize.x = 2;
  140.             track.ptlMinTrackSize.y = 2;  
  141.             track.ptlMaxTrackSize.x = 640;
  142.             track.ptlMaxTrackSize.y = 480; 
  143.  
  144.             track.fs = TF_RIGHT | TF_BOTTOM;
  145.  
  146.             if (!WinTrackRect(hwnd, NULLHANDLE, &track) ) {
  147.                 ptr1->reset();
  148.                 return(FALSE);
  149.             }
  150.             ptr1->reset();
  151.             start.PMPoint(track.rclTrack.xLeft,track.rclTrack.yBottom);
  152.             end.PMPoint(track.rclTrack.xRight,track.rclTrack.yTop);
  153.             addControl();
  154.             newControl=0;
  155.         case WM_MOUSEMOVE:
  156.             ptr1->set();
  157.             event.ret=(MRESULT)TRUE;
  158.             return TRUE;
  159.     }
  160.     return FALSE;
  161. }    
  162.  
  163. BOOL WorkWindow::other(PMEvent& evt) 
  164. {
  165.     switch (evt.msg) {
  166.         case WM_NEWCTRL:
  167.             ptr1->set();
  168.             newControl=(int)evt.mp1;
  169.             return TRUE;
  170.         case WM_CTRLMENU: {
  171.             _dlgcontrol* p=dlginfo->dlgctrl;
  172.             while (p!=NULL) {
  173.                 if (p->win==(ControlWin*)evt.mp1) {
  174.                     PMPoint pt(SHORT1FROMMP(evt.mp2)+d2rx(p->x),SHORT2FROMMP(evt.mp2)+d2ry(p->y));
  175.                     edctrl=p;
  176.                     popup->popup(pt,IDM_PU_PROP);
  177.                     break;
  178.                 }
  179.                 p=p->next;
  180.             }                
  181.             return TRUE;
  182.         }
  183.         default:
  184.             return FALSE;
  185.     }
  186.     return FALSE;
  187. }
  188.  
  189. BOOL WorkWindow::command(USHORT id,USHORT cmddev)
  190. {
  191.     switch (id) {
  192.         case IDM_PU_DELETE: {
  193.             _dlgcontrol *p=dlginfo->dlgctrl,**pp=&dlginfo->dlgctrl;
  194.             while (p!=NULL) {
  195.                 if (p==edctrl) {
  196.                     _dlgcontrol *old=p;
  197.                     *pp=p->next;
  198.                     old->win->destroyWin();
  199.                     delete old;
  200.                     break;
  201.                 }
  202.                 p=p->next;
  203.                 pp=&((*pp)->next);
  204.             }                
  205.             editor->postMsg(WM_MODIFIED);            
  206.             invalidate(TRUE);
  207.             return TRUE;
  208.         }
  209.         case IDM_PU_FLAGS: {
  210.             CtrlFlagsDialog cfd(hwnd,edctrl);
  211.             cfd.createWin();
  212.             edctrl->win->destroyWin();
  213.             edctrl->win=new ControlWin(this,apszClasses[edctrl->classidx],
  214.                 edctrl->text, edctrl->flags, d2rx(edctrl->x), d2ry(edctrl->y), d2rx(edctrl->cx), d2ry(edctrl->cy),
  215.                 HWND_BOTTOM, edctrl->idl);
  216.             edctrl->win->createWin();
  217.             editor->postMsg(WM_MODIFIED);            
  218.             invalidate(TRUE);
  219.             return TRUE;
  220.         }
  221.         case IDM_PU_PROP: {
  222.             struct _cp {
  223.                 char cx[10];
  224.                 char cy[10];
  225.                 char x[10];
  226.                 char y[10];
  227.                 char text[80];
  228.                 char label[80];
  229.             } cp;
  230.             static PMControlMap ctrlmap[]={
  231.                 cmEntryField(DCP_EF_CX,_cp,cx)
  232.                 cmEntryField(DCP_EF_CY,_cp,cy)
  233.                 cmEntryField(DCP_EF_X,_cp,x)
  234.                 cmEntryField(DCP_EF_Y,_cp,y)
  235.                 cmEntryField(DCP_EF_TEXT,_cp,text)
  236.                 cmEntryField(DCP_EF_LABEL,_cp,label)
  237.                 cmEnd(DCP_EF_X)
  238.             };
  239.             sprintf(cp.cx,"%ld",edctrl->cx);
  240.             sprintf(cp.cy,"%ld",edctrl->cy);
  241.             sprintf(cp.x,"%ld",edctrl->x);
  242.             sprintf(cp.y,"%ld",edctrl->y);
  243.             strcpy(cp.text,edctrl->text);
  244.             strcpy(cp.label,edctrl->idc);
  245.             PMModalDialog propdlg(HWND_DESKTOP,hwnd,DLG_CTRLPROP,ctrlmap,&cp);
  246.             int ret=propdlg.createWin();
  247.             if (ret) {
  248.                 edctrl->x=atoi(cp.x);
  249.                 edctrl->y=atoi(cp.y);
  250.                 edctrl->cx=atoi(cp.cx);
  251.                 edctrl->cy=atoi(cp.cy);
  252.                 strcpy(edctrl->text,cp.text);
  253.                 strcpy(edctrl->idc,cp.label);
  254.                 edctrl->win->setWindowText(cp.text);
  255.                 edctrl->win->setPos(getHwnd(), d2rx(edctrl->x), d2ry(edctrl->y), d2rx(edctrl->cx), d2ry(edctrl->cy),SWP_SIZE|SWP_MOVE );
  256.                 editor->postMsg(WM_MODIFIED);            
  257.             }
  258.             return TRUE;
  259.         }
  260.     }
  261.     return PMWin::command(id,cmddev);
  262. }
  263.  
  264. /////////////////////////////////////////////////////////////////////////////
  265.  
  266.  
  267. class DlgEditor : public PMMainWin {
  268.     _dlginfo dlginfo;
  269.     WorkWindow *ww;
  270.     char* tempfile;
  271.     SHORT activatemenus;
  272.     CtrlListDialog *ctrllistdlg;
  273. protected:
  274. //    void getcurdir(char* buf)
  275. //    {
  276. //        ULONG drive,pathlen=CCHMAXPATH-8;
  277. //        DosQueryCurrentDisk(&drive,NULL);
  278. //        buf[0]='A'+drive;
  279. //        buf[1]=':';    buf[2]='\\';
  280. //        DosQueryCurrentDir(drive,buf+3,&pathlen);
  281. //    }
  282. public:
  283.     DlgEditor(HAB ab,char* file) : PMMainWin("dialogeditor",ab) {
  284.         createArgs->flCreateFlags|=FCF_MENU|FCF_ICON|FCF_ACCELTABLE;
  285.         createArgs->idResources=ID_DLGEDIT;
  286.         createArgs->pszTitle="Dialog Editor - (none)";
  287.         caption="Dialog Editor";
  288. //        fnFilter=new char[CCHMAXPATH];
  289. //        getcurdir(fnFilter);
  290. //        strcat(fnFilter,"*.DL");
  291. //        ErrBox(fnFilter);
  292.         fnFilter="*.DL";
  293.         fileFlags=PMMWFF_UNTITLED;
  294.         flCaption="Open Dialog File";
  295.         fsCaption="Save Dialog File";
  296.         dlginfo._dlginfo();
  297.         ww=NULL;
  298.         tempfile=file;
  299.         activatemenus=FALSE;
  300.         ctrllistdlg=NULL;
  301.     };
  302.     BOOL createWin() 
  303.     {
  304.         PMMainWin::createWin();
  305.         return TRUE;
  306.     }    
  307.     void setmenus(PMMenu* menu,BOOL st)
  308.     {
  309.         menu->enableItem(IDM_SIZE,st);
  310.         menu->enableItem(IDM_TEXT,st);
  311.         menu->enableItem(IDM_FLAGS,st);
  312.         menu->enableItem(IDM_CTRLLIST,st);
  313.         menu->enableItem(IDM_STATICTEXT,st);
  314.         menu->enableItem(IDM_ENTRYFIELD,st);
  315.         menu->enableItem(IDM_LISTBOX,st);
  316.         menu->enableItem(IDM_COMBOBOX,st);
  317.         menu->enableItem(IDM_BUTTON,st);
  318.         menu->enableItem(IDM_SPINBUTTON,st);
  319.         menu->enableItem(IDM_SLIDER,st);
  320.         menu->enableItem(IDM_VALUESET,st);
  321.         menu->enableItem(IDM_CHECKBOX,st);
  322.         menu->enableItem(IDM_RADIOBUTTON,st);
  323.         menu->enableItem(IDM_3STATE,st);
  324.         menu->enableItem(IDM_GROUPBOX,st);
  325.     }
  326.     BOOL initmenu(SHORT id,PMMenu* menu)
  327.     {
  328.         if (id==IDM_PREF || id==IDM_NEWCTRL) {
  329.             setmenus(menu,activatemenus);
  330.         }
  331.         if (ctrllistdlg) menu->enableItem(IDM_CTRLLIST,FALSE);
  332.         return TRUE;
  333.     }
  334.     BOOL destroyWin()
  335.     {
  336.         if (ctrllistdlg) ctrllistdlg->destroyWin();
  337.         if (ww) ww->destroyWin();
  338.         return PMMainWin::destroyWin();
  339.     }                             
  340.     ~DlgEditor() {
  341. //        delete fnFilter;
  342.     }
  343.     BOOL paint(PMPresSpace& ps)
  344.     {
  345.         PMRect rcl;
  346.         rcl=this;
  347.         ps.fillRect(&rcl,CLR_PALEGRAY);
  348.         if (!aveCharX) {
  349.             PMDeviceContext dc(ab,ps.queryDevice());
  350.             LONG d,e;
  351.             dc.queryCaps(CAPS_GRAPHICS_CHAR_WIDTH,1,&d);
  352.             dc.queryCaps(CAPS_GRAPHICS_CHAR_HEIGHT,1,&e);
  353.             dc.queryCaps(CAPS_CHAR_WIDTH,1,&aveCharX);
  354.             dc.queryCaps(CAPS_CHAR_HEIGHT,1,&aveCharY);
  355.             SIZEF cb;
  356.             ps.queryCharBox(&cb);
  357. //            msgBox("Result","%ld %ld %ld %ld %f %f",aveCharX,aveCharY,d,e,((float)cb.cx) / 0x10000,((float)cb.cy) / 0x10000);
  358.         }
  359.         if (tempfile)
  360.             if (fileOpen(tempfile)) {
  361.                 strcpy(filename,tempfile);
  362.                 fileFlags=PMMWFF_FILE;
  363.                 setTitleCaption();
  364.                 tempfile=NULL;
  365.             }
  366.         if (ww) ww->setFramePos(getHwnd(),10,10,d2rx(dlginfo.sx),d2ry(dlginfo.sy),SWP_SIZE|SWP_MOVE|SWP_SHOW|SWP_ACTIVATE);
  367.         return TRUE;
  368.     }
  369.     BOOL mouse(PMEvent& event)
  370.     {
  371.         return FALSE;
  372.     }
  373.     BOOL command(USHORT id,USHORT cmddev)
  374.     {
  375.         switch (id) {
  376.             case IDM_STATICTEXT: 
  377.             case IDM_LISTBOX: 
  378.             case IDM_ENTRYFIELD: 
  379.             case IDM_COMBOBOX:
  380.             case IDM_BUTTON:
  381.             case IDM_SPINBUTTON:
  382.             case IDM_SLIDER:
  383.             case IDM_VALUESET:
  384.             case IDM_CHECKBOX:
  385.             case IDM_RADIOBUTTON:
  386.             case IDM_3STATE:
  387.             case IDM_GROUPBOX:
  388.                 if (ww) ww->postMsg(WM_NEWCTRL,(MPARAM)id);
  389.                 setModified(TRUE);
  390.                 return TRUE;
  391.             case IDM_COMPILE:    
  392.                 compile(filename,&dlginfo);
  393.                 return TRUE;
  394.             case IDM_FONTS:    {
  395. /*                FONTMETRICS fm;
  396.                 char buf[200];
  397.                 PMWindowPresSpace ps(this);
  398.                 ps.queryFontMetrics(&fm);
  399.                 PMFontDialog fd(HWND_DESKTOP,hwnd, &fm,"Titolo","Preview");
  400.                 int ret=fd.createWin();
  401.                 assert(ret);
  402.                 FONTDLG fi=fd;
  403.                 sprintf(buf,"%d %s %ld %hd %hd %hd %hd",ret,fi.pszFamilyname,fi.fxPointSize,fi.usWeight,fi.usWidth,fi.x,fi.y);
  404.                 msgBox("Result",buf); */
  405.                 return TRUE;
  406.             }
  407.             case IDM_SIZE:    {
  408.                 struct _dlgsize {
  409.                     char sx[10];
  410.                     char sy[10];
  411.                 } dlgsize;
  412.                 static PMControlMap ctrlmap[]={
  413.                     cmEntryField(DSIZE_EF_SX,_dlgsize,sx)
  414.                     cmEntryField(DSIZE_EF_SY,_dlgsize,sy)
  415.                     cmEnd(DSIZE_EF_SX)
  416.                 };
  417.                 sprintf(dlgsize.sx,"%d",dlginfo.sx);
  418.                 sprintf(dlgsize.sy,"%d",dlginfo.sy);
  419.                 PMModalDialog sizedlg(HWND_DESKTOP,hwnd,DLG_SIZE,ctrlmap,&dlgsize);
  420.                 int ret=sizedlg.createWin();
  421.                 if (ret) {
  422.                     dlginfo.sx=atoi(dlgsize.sx);
  423.                     dlginfo.sy=atoi(dlgsize.sy);
  424.                     if (ww) ww->setFramePos(getHwnd(),10,10,d2rx(dlginfo.sx),d2ry(dlginfo.sy),SWP_SIZE|SWP_MOVE);
  425.                     else {
  426.                         ww=new WorkWindow(ab,&dlginfo,this);
  427.                         ww->createWin();
  428.                     }
  429.                     setModified(TRUE);
  430.                 }
  431.                 return TRUE;
  432.             }
  433.             case IDM_TEXT:    {
  434.                 struct _dlgtext {
  435.                     char lb[100];
  436.                     char ti[100];
  437.                 } dlgtext;
  438.                 static PMControlMap ctrlmap[]={
  439.                     cmEntryField(DTEXT_EF_LB,_dlgtext,lb)
  440.                     cmEntryField(DTEXT_EF_TI,_dlgtext,ti)
  441.                     cmEnd(DTEXT_EF_TI)
  442.                 };
  443.                 strcpy(dlgtext.ti,dlginfo.title);
  444.                 strcpy(dlgtext.lb,dlginfo.label);
  445.                 PMModalDialog textdlg(HWND_DESKTOP,hwnd,DLG_TEXT,ctrlmap,&dlgtext);
  446.                 int ret=textdlg.createWin();
  447.                 if (ret) {
  448.                     strcpy(dlginfo.title,dlgtext.ti);
  449.                     strcpy(dlginfo.label,dlgtext.lb);
  450.                     if (ww) ww->setFrameWindowText(dlginfo.title);
  451.                     else {
  452.                         ww=new WorkWindow(ab,&dlginfo,this);
  453.                         ww->createWin();
  454.                     }
  455.                     setModified(TRUE);
  456.                 }
  457.                 return TRUE;
  458.             }
  459.             case IDM_FLAGS:    {
  460.                 int i;
  461.                 _windowflags windowflags;
  462.                 for (i=0; i<26; i++) windowflags.fl[i]=dlginfo.fl[i];
  463.                 PMModalDialog flagsdlg(HWND_DESKTOP,hwnd,DLG_FLAGS,windowflagsctrlmap,&windowflags);
  464.                 int ret=flagsdlg.createWin();
  465.                 if (ret) {
  466.                     for (i=0; i<26; i++) dlginfo.fl[i]=windowflags.fl[i];
  467.                     if (ww) ww->destroyWin();
  468.                     ww=new WorkWindow(ab,&dlginfo,this);
  469.                     ww->createWin();
  470.                     setModified(TRUE);
  471.                 }
  472.                 return TRUE;
  473.             }
  474.             case IDM_CTRLLIST: {
  475.                 if (!ctrllistdlg)
  476.                     ctrllistdlg=new CtrlListDialog(HWND_DESKTOP,hwnd,ww,this);
  477.  
  478.                 ctrllistdlg->createWin();
  479.                 return TRUE;
  480.             }
  481.         }        
  482.         return PMMainWin::command(id,cmddev);
  483.     }
  484.     BOOL fileNew() {
  485.         if (ww)    ww->destroyWin();
  486.         
  487.         _dlgcontrol* p=dlginfo.dlgctrl;
  488.         while (p!=NULL) { // cancella i controlli
  489.             _dlgcontrol* old=p;
  490.             p=p->next;
  491.             delete old;            
  492.         }
  493.         dlginfo._dlginfo();
  494.         ww=new WorkWindow(ab,&dlginfo,this);
  495.         ww->createWin();
  496.         setFrameWindowText("Dialog Editor - (untitled)");
  497.         activatemenus=TRUE;
  498.         return TRUE;
  499.     }
  500.     BOOL fileOpen(PCSZ filename) {
  501.         if (ww)    ww->destroyWin();
  502.         
  503.         _dlgcontrol* p=dlginfo.dlgctrl;
  504.         while (p!=NULL) { // cancella i controlli
  505.             _dlgcontrol* old=p;
  506.             p=p->next;
  507.             delete old;            
  508.         }
  509.         dlginfo._dlginfo();
  510.  
  511.         if (loaddl(filename,&dlginfo)) {
  512.             ww=new WorkWindow(ab,&dlginfo,this);
  513.             ww->createWin();
  514.             activatemenus=TRUE;
  515.             return TRUE;
  516.         }
  517.  
  518.         ErrBox("Error Loading file %s",filename);
  519.  
  520.         return FALSE;
  521.     };
  522.     BOOL fileSave(PCSZ filename) {
  523.         savedl(filename,&dlginfo);
  524.         invalidate(TRUE);
  525.         return TRUE;
  526.     };
  527.     BOOL other(PMEvent& evt) 
  528.     {
  529.         if (evt.msg==WM_MODIFIED) {
  530.             if (ctrllistdlg) ctrllistdlg->postMsg(WM_REFRESH);            
  531.             setModified(TRUE);
  532.             return TRUE;
  533.         }
  534.         if (evt.msg==WM_CLOSECTRLLIST) {
  535.             ctrllistdlg=NULL;
  536.             return TRUE;
  537.         }
  538.         return FALSE;
  539.     }
  540. };
  541.  
  542.  
  543. int main (int argc,char* argv[])
  544. {
  545.     char* file=NULL;
  546.     if (argc>1) {
  547.         // ci sono switch
  548.         if (argv[1][0]=='-')
  549.             if (argv[1][1]=='c') { 
  550.                 compile(argv[2],NULL);
  551.                 return 0;
  552.             }
  553.         file=argv[1];
  554.     }
  555.  
  556.     PMAnchorBlock ab;
  557.     PMMessageQueue mq;
  558.     ab.init();
  559.     mq.create(ab);
  560.     
  561.     App=new PMApp(ab,mq,argc,argv);
  562.  
  563.     DlgEditor * de=new DlgEditor(ab,file); // dagli anche il nome di un'eventuale file
  564.     de->createWin();
  565.     
  566.     App->run();
  567.  
  568.     de->destroyWin();
  569.  
  570.     mq.destroy();
  571.     ab.uninit();
  572.  
  573.     return (0);
  574. }
  575.  
  576.  
  577.