开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
testxres.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：19k
源码类别：

Symbian

开发平台：

C/C++

testxres.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #ifndef _UNIX
  37. #include <windows.h>
  38. #endif
  40. #include "hxtypes.h"
  41. #include "hxresult.h"
  42. #include "pnpeff.h"
  43. #include "dllacces.h"
  44. #include "dllpath.h"
  45. #include "hxslist.h"
  46. #include "pnxres.h"
  47. #include "pnxbmp.h"
  48. #include "hlxclib/stdlib.h"
  49. #include "hlxclib/string.h"
  50. #include "hlxclib/stdio.h"
  51. #include "chxdataf.h"
  53. #include "hxassert.h"
  54. #include "pnxdlog.h"
  55. #include "pnxmenu.h"
  56. #include "pnxmbar.h"
  57. #include "pnxcrsr.h"
  58. #include "pnxicon.h"
  60. ENABLE_DLLACCESS_PATHS(Testxres);
  62. #ifdef _MACINTOSH
  63. #include <console.h>
  64. #include "macfd.h"
  65. #include "resource.h"
  68. void    AddSubMenu(MenuHandle   menu, CHXXMenu* pMenu,UINT16*  index);
  70. #endif
  73. #ifdef _UNIX
  74. #include <fcntl.h> // for O_CREAT, O_WRONLY, etc.
  75. #include <Xm/PushB.h>
  76. #include "xpm.h"
  77. //#include <X11/xpm.h>
  78. #endif
  80. ULONG32         gSubMenuID=2;
  81. ULONG32         gSubLevel=1;
  83. typedef HX_RESULT (HXEXPORT_PTR FPCREATEINSTANCE) (IUnknown** /*OUT*/ ppIUnknown);
  85. BOOL OpenLibPNCreateInstance(char* dllName, UINT32 uDLLNameLen, const char* szShortName,const char* szLongName,DLLAccess& lib,IUnknown** pObj)
  86. {
  87.     
  88.     DLLAccess::CreateName(szShortName,szLongName, dllName, uDLLNameLen);
  89.     if (DLLAccess::DLL_OK != lib.open(dllName))
  90. return(FALSE);
  91.     FPCREATEINSTANCE fpCreateInstance = (FPCREATEINSTANCE)lib.getSymbol("HXCreateInstance");
  92.     fpCreateInstance(pObj);
  94.     HX_ASSERT(*pObj);
  95.     if (!*pObj)
  96. return FALSE;
  98.     return TRUE;
  99. }
  103. extern "C" int main (int argc,char** argv)
  105. {
  106.   IHXXResource*  rsrc;
  108. #ifdef _MACINTOSH
  110. InitGraf(&qd.thePort);
  111. InitFonts();
  112. FlushEvents(everyEvent, 0);
  113. InitWindows();
  114. InitMenus();
  115. TEInit();
  116. InitDialogs(nil);
  117. InitCursor();
  118. DrawMenuBar();  
  120. argc = ccommand(&argv);
  121. #endif
  126. DLLAccess           PNXResLib;
  128. //
  129. //      SIMPLE TEST
  130. //
  135. IHXXResFile*           theFile=NULL;
  136. UINT16          ID;
  138.     // used for DLL name creation
  139.     const UINT32 MAX_DLL_NAME_LEN = 256;
  140.     char dllName[MAX_DLL_NAME_LEN]; /* Flawfinder: ignore */
  141.     UINT32 uDLLNameLen = MAX_DLL_NAME_LEN;
  143. if (!OpenLibPNCreateInstance(dllName,uDLLNameLen,"pnxr","pnxres",PNXResLib,(IUnknown**)&theFile))
  144. {
  146. printf("ERROR: Could not find %sn",dllName);
  147. return 0;
  149. }
  153. if (strcmp(argv[1],"CACHETEST")==0)
  154. {
  156. if (HXR_OK != theFile->Open(argv[2]))
  157. {
  158. printf("ERROR: file could not be opened.n");
  159. }
  161. for (int x=101; x<=115; x++)
  162. {
  164. if (HXR_OK==theFile->GetResource(HX_RT_BITMAP,x,&rsrc))
  165. {
  166. rsrc->Release();
  167. }
  169. }
  171. theFile->Close();
  173. return 0;
  174. }
  176. if (strcmp(argv[1],"DIALOG")==0)
  177. {
  178. if (HXR_OK != theFile->Open(argv[2]))
  179. {
  180. printf("ERROR: File could not be openend.n");
  181. }
  183. ULONG32 id=atoi(argv[3]);
  185. IHXXResource*  rsrc;
  187. if (HXR_OK == theFile->GetResource(HX_RT_DIALOG,id,&rsrc))
  188. {
  189. CHXXDialog*     theDialog=CHXXDialog::create(rsrc);
  191. rsrc->Release();
  193. //
  194. //      Draw out the things in the dialog, into a Window so that we can see how
  195. //      it is layed out.
  196. //
  198. #ifdef _MACINTOSH
  200. HX_DialogBoxHeader*       dlgh;
  201. HX_ControlData*           c=NULL;
  202. short                             index=0;
  204. GrafPtr         saveport; GetPort(&saveport);
  206. HX_RESULT       GetDialogHeader(HX_DialogBoxHeader**            h);
  208. theDialog->GetDialogHeader(&dlgh);
  210. Rect            wRect={50,50,dlgh->cy+50,dlgh->cx+50};
  212. WindowPtr       myWind=NewWindow(NULL,&wRect,"pStringParsing",TRUE,2,(WindowPtr)-1L, FALSE,NULL); 
  214. ShowWindow(myWind);
  215. SetPort(myWind);
  217. //
  218. //      Draw my dialog's items
  219. //
  221. while (HXR_OK==theDialog->GetNthControl(&c,index))
  222. {
  223. Rect  iRect={c->y,c->x,c->cy+c->y,c->cx+c->x};
  225. FrameRect(&iRect);
  227. index++;
  228. }
  230. while (!Button())
  231. {
  232. EventRecord     theEvent;
  234. WaitNextEvent(everyEvent,&theEvent,0xFF,NULL);
  235. }
  237. DisposeWindow(myWind);
  239. SetPort(saveport);
  240. #endif  
  242. }
  243. else
  244. {
  245. printf("ERROR: Dialog resource %d not found.",id);
  246. }
  249. return 0;
  250. }
  253. //
  254. //      Test the ability to display a bitmap.
  255. //
  257. if (strcmp(argv[1],"BITMAP")==0)
  258. {
  259. if (HXR_OK != theFile->Open(argv[2]))
  260. {
  261. printf("ERROR: File could not be openend.n");
  262. }
  264. ULONG32 id=atoi(argv[3]);
  266. IHXXResource*  rsrc=NULL;
  268. if (HXR_OK == theFile->GetResource(HX_RT_BITMAP,id,&rsrc))
  269. {
  271. #ifdef _MACINTOSH
  273. short                             index=0;
  275. GrafPtr         saveport; GetPort(&saveport);
  277. Rect            wRect={50,50,600,800};
  279. WindowPtr       myWind=NewWindow(NULL,&wRect,"pStringParsing",TRUE,2,(WindowPtr)-1L, FALSE,NULL); 
  281. ShowWindow(myWind);
  282. SetPort(myWind);
  285. //
  286. //      Okay make a CHXXBmp object, and feed the resource data we got into it.
  287. //              
  289. CHXXBitmap*        bmp;
  291. bmp=CHXXBitmap::create(rsrc);
  293. rsrc->Release();
  295. if (bmp)
  296. {
  298. Rect*   rect=*bmp;
  300. PixMapHandle thePixMap = GetGWorldPixMap( ( GWorldPtr ) *bmp );
  301. CopyBits((const BitMap*)*thePixMap,(const BitMap*)&myWind->portBits,*bmp,*bmp,srcCopy,NULL);
  302. ValidRect((Rect*)bmp);
  303. }
  307. while (!Button())
  308. {
  309. EventRecord     theEvent;
  311. WaitNextEvent(everyEvent,&theEvent,0xFF,NULL);
  312. }
  314. DisposeWindow(myWind);
  316. SetPort(saveport);
  318. bmp->Release();
  319. #endif  
  322. #ifdef _UNIX
  324. //
  325. //      Generate an XPM file.
  326. //                      
  328. CHXXBitmap* bmp;
  329. bmp=CHXXBitmap::create(rsrc);
  331. rsrc->Release();
  333. CHXDataFile*    outputfile;
  335. outputfile=CHXDataFile::Construct();
  337. if (outputfile)
  338. {               
  339. printf ("Width=%d Height=%dnconverteddata=0x%x converteddatasize=%dncommondata=0x%x commondatasize=%dn",
  340. bmp->m_Width,
  341. bmp->m_Height,
  342. bmp->m_ConvertedData,
  343. bmp->m_ConvertedDataSize,
  344. bmp->m_CommonData,
  345. bmp->m_CommonDataSize);
  347. outputfile->Open(argv[4],O_RDWR|O_CREAT);
  349. //outputfile->Write((char*)*bmp,strlen(*bmp));
  350. outputfile->Write((char*)(bmp->m_ConvertedData),bmp->m_ConvertedDataSize);
  351. outputfile->Close();
  353. delete outputfile;
  354. }
  355. else
  356. {
  357. printf("Could not create file object.r");
  358. }
  361. #if 1
  362. XtAppContext app;
  363. Widget top, button;
  364. int status;
  365. Pixmap pixmap;
  366. XpmImage image;
  367. top = XtAppInitialize(&app, "TestButton", NULL, 0, &argc, argv,
  368. NULL, NULL, 0);
  369. button = XmCreatePushButton(top, "button", NULL, 0);
  370. status = XpmCreateXpmImageFromData ((CHAR **)(bmp->m_ConvertedData),
  371. &image, NULL);
  372. status = XpmCreatePixmapFromXpmImage (XtDisplay(top),
  373. XRootWindowOfScreen(XtScreen(top)),
  374. &image, &pixmap, NULL, NULL);
  375. if (status != XpmSuccess)
  376. {
  377. fprintf (stderr, "XpmError:  %sn", XpmGetErrorString(status));
  378. exit(1);
  379. }
  380. XtVaSetValues(button,
  381. XmNlabelType, XmPIXMAP,
  382. XmNlabelPixmap, pixmap,
  383. NULL);
  384. XtManageChild(button);
  385. XtRealizeWidget(top);
  386. XtAppMainLoop(app);
  387. #endif
  390. delete bmp;
  392. #endif
  395. }
  396. else
  397. {
  398. printf("ERROR: Dialog resource %d not found.",id);
  399. }
  401. return 0;
  402. }
  405. if (strcmp(argv[1],"BITMAPFILE")==0)
  406. {
  407. {
  409. ULONG32 id=atoi(argv[3]);
  412. #ifdef _MACINTOSH
  415. c2pstr(argv[2]);
  417. FSSpec  theFileSpec;
  418. short   fileRef=0;
  419. long    eof=0;
  421. FSMakeFSSpec(0,0,(StringPtr)argv[2],&theFileSpec);
  423. FSpOpenDF(&theFileSpec,fsRdPerm,&fileRef);
  424. GetEOF(fileRef,&eof);
  426. BYTE*   buffer=new BYTE[eof];
  427. BYTE*   p=buffer+14;
  429. HX_ASSERT(buffer);
  431. FSRead(fileRef,&eof,buffer);
  433. FSClose(fileRef);
  436. short                             index=0;
  438. GrafPtr         saveport; GetPort(&saveport);
  440. Rect            wRect={50,50,600,800};
  442. WindowPtr       myWind=NewWindow(NULL,&wRect,"pStringParsing",TRUE,2,(WindowPtr)-1L, FALSE,NULL); 
  444. ShowWindow(myWind);
  445. SetPort(myWind);
  448. //
  449. //      Okay make a CHXXBmp object, and feed the resource data we got into it.
  450. //              
  452. CHXXBitmap*        bmp;
  454. bmp=CHXXBitmap::create((HX_BITMAPINFO*)p);
  457. if (bmp)
  458. {
  460. Rect*   rect=*bmp;
  462. PixMapHandle thePixMap = GetGWorldPixMap( ( GWorldPtr ) *bmp );
  463. CopyBits((const BitMap*)*thePixMap,(const BitMap*)&myWind->portBits,*bmp,*bmp,srcCopy,NULL);
  464. ValidRect((Rect*)bmp);
  465. }
  469. while (!Button())
  470. {
  471. EventRecord     theEvent;
  473. WaitNextEvent(everyEvent,&theEvent,0xFF,NULL);
  474. }
  476. DisposeWindow(myWind);
  478. SetPort(saveport);
  480. bmp->Release();
  481. #endif  
  484. #ifdef _UNIX
  486. //
  487. //      Generate an XPM file.
  488. //                      
  490. CHXXBitmap* bmp;
  491. bmp=CHXXBitmap::create(rsrc);
  493. rsrc->Release();
  495. CHXDataFile*    outputfile;
  497. outputfile=CHXDataFile::Construct();
  499. if (outputfile)
  500. {               
  501. outputfile->Create(argv[4],O_CREAT);
  502. outputfile->Open(argv[4],O_WRONLY);
  504. outputfile->Write((char*)*bmp,strlen(*bmp));
  505. outputfile->Close();
  507. delete outputfile;
  508. }
  509. else
  510. {
  511. printf("Could not create file object.r");
  512. }
  514. delete bmp;
  516. #endif
  519. }
  521. return 0;
  522. }
  526. if (strcmp(argv[1],"ICON")==0)
  527. {
  529. if (HXR_OK != theFile->Open(argv[2]))
  530. {
  531. printf("ERROR: file could not be opened.n");
  532. }
  533. else
  534. {
  536. ULONG32 id=atoi(argv[3]);
  539. #ifdef _MACINTOSH
  541. short                             index=0;
  543. GrafPtr         saveport; GetPort(&saveport);
  545. Rect            wRect={50,50,600,800};
  547. WindowPtr       myWind=NewWindow(NULL,&wRect,"pStringParsing",TRUE,2,(WindowPtr)-1L, FALSE,NULL); 
  549. ShowWindow(myWind);
  550. SetPort(myWind);
  552. //
  553. // Load the icon first
  554. //
  556. IHXXResource*    iconresource;
  558. if (HXR_OK==theFile->GetResource(HX_RT_GROUPICON,id,&rsrc))
  559. {
  561. //
  562. // Create an Icon parser object
  563. //
  565. CHXXIcon*    icon;
  566. icon=CHXXIcon::create(rsrc);
  568. #if 0 /* needs to be re-worked with new icon drawing code */
  569. if (icon)
  570. {
  572. CIconHandle        macicon;
  575. macicon=icon->GetIconHandle();
  577. Rect aRect={0,0,31,31};
  578. FillRect(&aRect,&qd.ltGray);
  579. PlotCIcon(&aRect,macicon);
  581. aRect.top+=32;
  582. aRect.bottom+=32;
  583. FillRect(&aRect,&qd.gray);
  584. PlotCIcon(&aRect,macicon);
  586. aRect.top+=32;
  587. aRect.bottom+=32;
  588. FillRect(&aRect,&qd.dkGray);
  589. PlotCIcon(&aRect,macicon);
  591. aRect.top+=32;
  592. aRect.bottom+=32;
  593. FillRect(&aRect,&qd.white);
  594. PlotCIcon(&aRect,macicon);
  597. aRect.top+=32;
  598. aRect.bottom+=32;
  599. FillRect(&aRect,&qd.black);
  600. PlotCIcon(&aRect,macicon);
  604. while (!Button())
  605. {
  606. EventRecord     theEvent;
  608. WaitNextEvent(everyEvent,&theEvent,0xFF,NULL);
  609. }
  611. HX_DELETE(icon);
  613. }
  614. #endif //
  615. HX_RELEASE(rsrc);
  617. }
  618. DisposeWindow(myWind);
  620. SetPort(saveport);
  622. #endif  
  625. }
  627. return 0;
  628. }
  632. //
  633. //      Menu test
  634. //
  637. if (strcmp(argv[1],"MENU")==0)
  638. {
  639. if (HXR_OK != theFile->Open(argv[2]))
  640. {
  641. printf("ERROR: File could not be openend.n");
  642. }
  644. ULONG32 id=atoi(argv[3]);
  646. IHXXResource*  rsrc=NULL;
  649. if (HXR_OK == theFile->GetResource(HX_RT_MENU,id,&rsrc))
  650. {               
  652. #ifdef _MACINTOSH
  654. CHXXMenu*        pMenu=CHXXMenu::create(rsrc);
  656. rsrc->Release();
  658. if (!pMenu)
  659. {
  660. return;
  661. }
  663. UINT16                          menuid=atoi(argv[3]);
  664. UINT16                          index=0;
  665. MenuHandle                      mainmenu;
  666. MenuHandle                      submenus[10];
  667. HX_MenuItem*            mi=NULL;
  668. ConstStr255Param        pstring;
  669. UINT16                          curitem=1;
  671. memset(submenus,0,sizeof(submenus));
  673. if (HXR_OK==pMenu->GetNthMenuItem(&mi,0))
  674. {
  675. CHXString       thestring;
  676. thestring=mi->szItemText;
  677. pstring=thestring;
  679. mainmenu=NewMenu(menuid,pstring);
  681. index=1;
  683. while (HXR_OK==pMenu->GetNthMenuItem(&mi,index))
  684. {
  685. pstring=mi->szItemText;
  688. if (!IS_POPUP_MENUITEM(mi))
  689. {
  690. if (IS_SEPARATOR_MENUITEM(mi))
  691. {
  692. AppendMenu(mainmenu,"p-");
  693. }
  695. AppendMenu(mainmenu,pstring);
  697. if (IS_DISABLED_MENUITEM(mi))
  698. {
  699. DisableItem(mainmenu,curitem);                                                  
  700. }
  702. if (IS_CHECKED_MENUITEM(mi))
  703. {
  704. CheckItem(mainmenu,curitem,TRUE);                                                       
  705. }                                               
  707. if (mi->wKey && (mi->fKeyFlags & HX_FCONTROL))
  708. {
  709. SetItemCmd(mainmenu,curitem,mi->wKey);
  710. }       
  712. }
  713. else
  714. {
  715. AddSubMenu(mainmenu,pMenu,&index);      
  716. }
  718. index++;
  719. curitem++;
  720. }
  723. InsertMenu(mainmenu,0);
  725. EventRecord     theEvent;
  728. DrawMenuBar();                          
  730. while (true)
  731. {
  732. if (WaitNextEvent(everyEvent,&theEvent,0xFF,NULL))
  733. {
  734. if (theEvent.what==autoKey)
  735. {
  736. break;
  737. }
  739. if (theEvent.what==mouseDown)
  740. {
  741. WindowPtr       whichWin;
  743. short part = FindWindow(theEvent.where,&whichWin);
  745. if (part == inMenuBar)
  746. {
  747. MenuSelect(theEvent.where);
  748. }
  750. }       
  752. }
  754. }
  756. }
  758. #endif
  762. #if 0
  763. //#ifdef _UNIX
  765. CHXXMenu*        pMenu=CHXXMenu::create(rsrc);
  766. HX_MenuItem*            mi=NULL;
  767. if (HXR_OK==pMenu->GetNthMenuItem(&mi,0))
  768. printf ("Menu: 0x%xnItem: %s %s %sn", pMenu, mi->szItemText, mi->szAcceleratorText, mi->szStatusText);
  770. #endif
  775. }
  776. }
  779. if (strcmp(argv[1],"MENUBAR")==0)
  780. {
  782. if (HXR_OK != theFile->Open(argv[2]))
  783. {
  784. printf("ERROR: file could not be opened.n");
  785. }
  787. ULONG32 id=atoi(argv[3]);
  789. IHXXResource*  rsrc=NULL;
  792. if (HXR_OK == theFile->GetResource(HX_RT_MENU,id,&rsrc))
  793. {               
  795. #ifdef _MACINTOSH
  796. CHXXMenuBar*    menubar=CHXXMenuBar::create(rsrc);
  798. ULONG32 index=0;
  799. CHXXMenu*               menu=NULL;
  801. gSubLevel=0;
  803. while (HXR_OK==menubar->GetMenuByIndex(&menu,index))
  804. {
  806. gSubLevel=0;
  808. UINT16  itemindex=0;
  810. AddSubMenu(NULL,menu,&itemindex);
  812. index++;
  813. }
  816. EventRecord     theEvent;
  818. DrawMenuBar();                          
  820. while (true)
  821. {
  822. if (WaitNextEvent(everyEvent,&theEvent,0xFF,NULL))
  823. {
  824. if (theEvent.what==autoKey)
  825. {
  826. break;
  827. }
  829. if (theEvent.what==mouseDown)
  830. {
  831. WindowPtr       whichWin;
  833. short part = FindWindow(theEvent.where,&whichWin);
  835. if (part == inMenuBar)
  836. {
  837. MenuSelect(theEvent.where);
  838. }
  840. }       
  842. }
  844. }
  846. #endif                  
  851. #if 0
  852. //#ifdef _UNIX
  854.             CHXXMenuBar*    menubar=CHXXMenuBar::create(rsrc);
  855. #endif                  
  859. }
  861. theFile->Close();
  863. return 0;
  864. }       
  867. if (strcmp(argv[1],"CURSOR")==0)
  868. {
  870. if (HXR_OK != theFile->Open(argv[2]))
  871. {
  872. printf("ERROR: file could not be opened.n");
  873. }
  875. ULONG32 id=atoi(argv[3]);
  877. IHXXResource*  rsrc=NULL;
  880. if (HXR_OK == theFile->GetResource(HX_RT_GROUPCURSOR,id,&rsrc))
  881. {               
  883. CHXXCursor*             theCursor=CHXXCursor::create(rsrc);
  884. #ifdef _MACINTOSH                
  885. HX_ASSERT(theCursor);
  887. if (theCursor)
  888. {
  889. SetCursor(*theCursor);
  890. }
  892. while (!Button())
  893. {
  894. EventRecord     theEvent;
  896. WaitNextEvent(everyEvent,&theEvent,0xFF,NULL);
  897. }
  898. #endif                
  900. }
  904. theFile->Close();
  906. return 0;
  907. }       
  909. if (strcmp(argv[1],"STRING")==0)
  910. {
  912. if (HXR_OK != theFile->Open(argv[2]))
  913. {
  914. printf("ERROR: File could not be opened.n");
  915. }
  917. IHXXResource*   res;
  919. ID= atoi(argv[3]);
  921. res=theFile->GetString(ID);
  923. if (res)
  924. {
  925. printf("%s",(char*)res->ResourceData());
  927. res->Release();
  928. }
  930. theFile->Close();
  932. return 0;
  933. }
  934. return 0;
  935. }
  938. #ifdef _MACINTOSH
  940. void    AddSubMenu(MenuHandle   menu, CHXXMenu* pMenu,UINT16*  index)
  941. {
  943. HX_MenuItem*    mi=NULL;
  946. pMenu->GetNthMenuItem(&mi,*index);
  948. MenuHandle      submenu=NewMenu(gSubMenuID++,mi->szItemText);
  949. ULONG32         curitem=1;
  951. if (menu)
  952. {
  953. InsertMenu  (submenu,-1);
  955. AppendMenu(menu,mi->szItemText);
  956. UINT16  thisitem=CountMenuItems(menu);
  957. SetItemCmd(menu,thisitem,hMenuCmd);
  958. SetItemMark(menu,thisitem,(char)(gSubMenuID-1));
  959. }
  960. else
  961. {
  962. InsertMenu (submenu,0);
  963. }               
  965. gSubLevel++;    
  967. (*index)++;
  968. while (HXR_OK==pMenu->GetNthMenuItem(&mi,*index))
  969. {
  971. if (IS_SEPARATOR_MENUITEM(mi))
  972. {
  973. AppendMenu(submenu,"p-");
  974. }
  977. if (mi->wSubLevel < gSubLevel)
  978. {
  979. (*index)--;
  980. gSubLevel--;
  981. return;
  982. }
  985. if (IS_POPUP_MENUITEM(mi))
  986. {
  987. AddSubMenu(submenu,pMenu,index);        
  988. }
  989. else
  990. {
  991. AppendMenu(submenu,mi->szItemText);     
  993. if (IS_DISABLED_MENUITEM(mi))
  994. {
  995. DisableItem(submenu,curitem);                                                   
  996. }
  998. if (IS_CHECKED_MENUITEM(mi))
  999. {
  1000. CheckItem(submenu,curitem,TRUE);                                                        
  1001. }
  1003. if (mi->wKey && (mi->fKeyFlags & HX_FCONTROL))
  1004. {
  1005. SetItemCmd(submenu,curitem,mi->wKey);
  1006. }               
  1008. }
  1010. curitem++;
  1011. (*index)++;
  1014. }
  1015. }
  1017. #endif