C++ (C#)实现获取NX PART预览图

VS环境下 C++版本：

int GetPreviewImage(const TCHAR* prtFile, const TCHAR* imageFile) 
{
    IStorage* pStorage = NULL;
    HRESULT hResult = StgOpenStorage(prtFile, NULL, STGM_READ | STGM_SHARE_DENY_WRITE, NULL, 0, &pStorage); 
    if (hResult != S_OK) 
    {
        return -1;
    }

    IStorage* pSubStorage = NULL;
    hResult = pStorage->OpenStorage(_T("images"), NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, NULL, 0, &pSubStorage); 
    if (hResult != S_OK) 
    {
        return -1;
    }

    IStream *pStream = NULL; 
    hResult = pSubStorage->OpenStream( L"preview", NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &pStream ); 
    if (hResult != S_OK) 
    {
        return -1;
    }

    const int nLen = 10*1024*1024;// 准备读入的长度 
    byte* image = new byte[nLen]; 
    if (NULL == image)
    {
        return -1;
    }

    ULONG actRead; 
    pStream->Read(
        image,       // 存放放入的数据的缓冲区 
        nLen,        // 要读入数据的长度，如不清楚可以设为较大的数 
        &actRead     // 实际读入的长度 
        ); 

    pStream->Release(); 
    pStorage->Release();
    pSubStorage->Release();

    ofstream outfile(imageFile, ios::binary); 
    outfile.write((char*)image, actRead); 
    outfile.close(); 
    delete image;
    return 0;
}

业内还盛传一个C#版本，封装好了一个叫“ThumbnailCreator”的类，用法如下：

        static void GetPartBmp(string sFileName)
        {
            string sOutputFileName = "";
            if (!File.Exists(sFileName))
            {
                return;
            } 
            sOutputFileName = sFileName.Substring(0, sFileName.LastIndexOf(".")) + ".bmp";          
            ThumbnailCreator thumbnail = new ThumbnailCreator();
            Image img = thumbnail.GetThumbnail(sFileName);
            if (img != null)
            {
                if (!File.Exists(sOutputFileName))
                {
                    File.Delete(sOutputFileName);
                }
                img.Save(sOutputFileName, ImageFormat.Bmp);
            }          
        }

ThumbnailCreator类实现：

using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;

namespace SharedClasses
{

    #region ThumbnailCreator

    /// Summary description for ThumbnailCreator.

    public class ThumbnailCreator : IDisposable
    {
        #region ShellFolder Enumerations
        [Flags]
        private enum ESTRRET : int
        {
            STRRET_WSTR = 0x0000, // Use STRRET.pOleStr
            STRRET_OFFSET = 0x0001, // Use STRRET.uOffset to Ansi
            STRRET_CSTR = 0x0002 // Use STRRET.cStr
        }
        [Flags]
        private enum ESHCONTF : int
        {
            SHCONTF_FOLDERS = 32,
            SHCONTF_NONFOLDERS = 64,
            SHCONTF_INCLUDEHIDDEN = 128
        }

        [Flags]
        private enum ESHGDN : int
        {
            SHGDN_NORMAL = 0,
            SHGDN_INFOLDER = 1,
            SHGDN_FORADDRESSBAR = 16384,
            SHGDN_FORPARSING = 32768
        }
        [Flags]
        private enum ESFGAO : int
        {
            SFGAO_CANCOPY = 1,
            SFGAO_CANMOVE = 2,
            SFGAO_CANLINK = 4,
            SFGAO_CANRENAME = 16,
            SFGAO_CANDELETE = 32,
            SFGAO_HASPROPSHEET = 64,
            SFGAO_DROPTARGET = 256,
            SFGAO_CAPABILITYMASK = 375,
            SFGAO_LINK = 65536,
            SFGAO_SHARE = 131072,
            SFGAO_READONLY = 262144,
            SFGAO_GHOSTED = 524288,
            SFGAO_DISPLAYATTRMASK = 983040,
            SFGAO_FILESYSANCESTOR = 268435456,
            SFGAO_FOLDER = 536870912,
            SFGAO_FILESYSTEM = 1073741824,
            SFGAO_HASSUBFOLDER = -2147483648,
            SFGAO_CONTENTSMASK = -2147483648,
            SFGAO_VALIDATE = 16777216,
            SFGAO_REMOVABLE = 33554432,
            SFGAO_COMPRESSED = 67108864
        }
        #endregion

        #region IExtractImage Enumerations
        private enum EIEIFLAG
        {
            IEIFLAG_ASYNC = 0x0001, // ask the extractor if it supports ASYNC extract (free threaded)
            IEIFLAG_CACHE = 0x0002, // returned from the extractor if it does NOT cache the thumbnail
            IEIFLAG_ASPECT = 0x0004, // passed to the extractor to beg it to render to the aspect ratio of the supplied rect
            IEIFLAG_OFFLINE = 0x0008, // if the extractor shouldn't hit the net to get any content neede for the rendering
            IEIFLAG_GLEAM = 0x0010, // does the image have a gleam ? this will be returned if it does
            IEIFLAG_SCREEN = 0x0020, // render as if for the screen (this is exlusive with IEIFLAG_ASPECT )
            IEIFLAG_ORIGSIZE = 0x0040, // render to the approx size passed, but crop if neccessary
            IEIFLAG_NOSTAMP = 0x0080, // returned from the extractor if it does NOT want an icon stamp on the thumbnail
            IEIFLAG_NOBORDER = 0x0100, // returned from the extractor if it does NOT want an a border around the thumbnail
            IEIFLAG_QUALITY = 0x0200 // passed to the Extract method to indicate that a slower, higher quality image is desired, re-compute the thumbnail
        }
        #endregion

        #region ShellFolder Structures
        [StructLayoutAttribute(LayoutKind.Sequential, Pack = 4, Size = 0, CharSet = CharSet.Auto)]
        private struct STRRET_CSTR
        {
            public ESTRRET uType;
            [MarshalAs(System.Runtime.InteropServices.UnmanagedType.ByValArray, SizeConst = 520)]
            public byte[] cStr;
        }

        [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Auto)]
        private struct STRRET_ANY
        {
            [FieldOffset(0)]
            public ESTRRET uType;
            [FieldOffset(4)]
            public IntPtr pOLEString;
        }

        [StructLayoutAttribute(LayoutKind.Sequential)]
        private struct SIZE
        {
            public int cx;
            public int cy;
        }
        #endregion

        #region Com Interop for IUnknown
        [ComImport, Guid("00000000-0000-0000-C000-000000000046")]
        [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
        private interface IUnknown
        {
            [PreserveSig]
            IntPtr QueryInterface(ref Guid riid, out IntPtr pVoid);

            [PreserveSig]
            IntPtr AddRef();

            [PreserveSig]
            IntPtr Release();
        }
        #endregion

        #region COM Interop for IMalloc
        [ComImportAttribute()]
        [GuidAttribute("00000002-0000-0000-C000-000000000046")]
        [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
        //helpstring("IMalloc interface")
        private interface IMalloc
        {
            [PreserveSig]
            IntPtr Alloc(int cb);

            [PreserveSig]
            IntPtr Realloc(
            IntPtr pv,
            int cb);

            [PreserveSig]
            void Free(IntPtr pv);

            [PreserveSig]
            int GetSize(IntPtr pv);

            [PreserveSig]
            int DidAlloc(IntPtr pv);

            [PreserveSig]
            void HeapMinimize();
        };
        #endregion

        #region COM Interop for IEnumIDList
        [ComImportAttribute()]
        [GuidAttribute("000214F2-0000-0000-C000-000000000046")]
        [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
        //helpstring("IEnumIDList interface")
        private interface IEnumIDList
        {
            [PreserveSig]
            int Next(
            int celt,
            ref IntPtr rgelt,
            out int pceltFetched);

            void Skip(
            int celt);

            void Reset();

            void Clone(
            ref IEnumIDList ppenum);
        };
        #endregion

        #region COM Interop for IShellFolder
        [ComImportAttribute()]
        [GuidAttribute("000214E6-0000-0000-C000-000000000046")]
        [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
        //helpstring("IShellFolder interface")
        private interface IShellFolder
        {
            void ParseDisplayName(
            IntPtr hwndOwner,
            IntPtr pbcReserved,
            [MarshalAs(UnmanagedType.LPWStr)] string lpszDisplayName,
            out int pchEaten,
            out IntPtr ppidl,
            out int pdwAttributes
            );

            void EnumObjects(
            IntPtr hwndOwner,
            [MarshalAs(UnmanagedType.U4)] ESHCONTF grfFlags,
            ref IEnumIDList ppenumIDList
            );

            void BindToObject(
            IntPtr pidl,
            IntPtr pbcReserved,
            ref Guid riid,
            ref IShellFolder ppvOut
            );

            void BindToStorage(
            IntPtr pidl,
            IntPtr pbcReserved,
            ref Guid riid,
            IntPtr ppvObj
            );

            [PreserveSig]
            int CompareIDs(
            IntPtr lParam,
            IntPtr pidl1,
            IntPtr pidl2
            );

            void CreateViewObject(
            IntPtr hwndOwner,
            ref Guid riid,
            IntPtr ppvOut
            );

            void GetAttributesOf(
            int cidl,
            IntPtr apidl,
            [MarshalAs(UnmanagedType.U4)] ref ESFGAO rgfInOut
            );

            void GetUIObjectOf(
            IntPtr hwndOwner,
            int cidl,
            ref IntPtr apidl,
            ref Guid riid,
            out int prgfInOut,
            ref IUnknown ppvOut
            );

            void GetDisplayNameOf(
            IntPtr pidl,
            [MarshalAs(UnmanagedType.U4)] ESHGDN uFlags,
            ref STRRET_CSTR lpName
            );

            void SetNameOf(
            IntPtr hwndOwner,
            IntPtr pidl,
            [MarshalAs(UnmanagedType.LPWStr)] string lpszName,
            [MarshalAs(UnmanagedType.U4)] ESHCONTF uFlags,
            ref IntPtr ppidlOut
            );

        };

        #endregion

        #region COM Interop for IExtractImage
        [ComImportAttribute()]
        [GuidAttribute("BB2E617C-0920-11d1-9A0B-00C04FC2D6C1")]
        [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
        //helpstring("IExtractImage"),
        private interface IExtractImage
        {
            void GetLocation(
            [Out(), MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszPathBuffer,
            int cch,
            ref int pdwPriority,
            ref SIZE prgSize,
            int dwRecClrDepth,
            ref int pdwFlags
            );

            void Extract(
            out IntPtr phBmpThumbnail
            );
        }

        #endregion

        #region UnManagedMethods for IShellFolder
        private class UnManagedMethods
        {
            [DllImport("shell32", CharSet = CharSet.Auto)]
            internal extern static int SHGetMalloc(out IMalloc ppMalloc);

            [DllImport("shell32", CharSet = CharSet.Auto)]
            internal extern static int SHGetDesktopFolder(out IShellFolder ppshf);

            [DllImport("shell32", CharSet = CharSet.Auto)]
            internal extern static int SHGetPathFromIDList(IntPtr pidl, StringBuilder pszPath);

            [DllImport("gdi32", CharSet = CharSet.Auto)]
            internal extern static int DeleteObject(IntPtr hObject);
        }
        #endregion

        #region Member Variables
        private IMalloc alloc = null;
        private bool disposed = false;
        private System.Drawing.Size desiredSize = new System.Drawing.Size(246, 184);
        private System.Drawing.Bitmap thumbNail = null;
        #endregion

        #region Implementation
        public System.Drawing.Bitmap ThumbNail
        {
            get
            {
                return thumbNail;
            }
        }

        public System.Drawing.Size DesiredSize
        {
            get
            {
                return desiredSize;
            }
            set
            {
                desiredSize = value;
            }
        }

        private IMalloc Allocator
        {
            get
            {
                if (!disposed)
                {
                    if (alloc == null)
                    {
                        //Kaushik - fails here at times
                        UnManagedMethods.SHGetMalloc(out alloc);
                    }
                }
                else
                {
                    System.Diagnostics.Debug.Assert(false, "Object has been disposed.");
                }
                return alloc;
            }
        }

        public System.Drawing.Bitmap GetThumbnail(string file)
        {
            if ((!File.Exists(file)) && (!Directory.Exists(file)))
            {
                throw new FileNotFoundException(
                String.Format("The file '{0}' does not exist", file),
                file);
            }

            if (thumbNail != null)
            {
                thumbNail.Dispose();
                thumbNail = null;
            }

            IShellFolder folder = null;
            try
            {
                folder = getDesktopFolder;
            }
            catch (Exception ex)
            {
                throw ex;
            }

            if (folder != null)
            {
                IntPtr pidlMain = IntPtr.Zero;
                try
                {
                    int cParsed = 0;
                    int pdwAttrib = 0;
                    string filePath = Path.GetDirectoryName(file);
                    pidlMain = IntPtr.Zero;
                    folder.ParseDisplayName(
                    IntPtr.Zero,
                    IntPtr.Zero,
                    filePath,
                    out cParsed,
                    out pidlMain,
                    out pdwAttrib);
                }
                catch (Exception ex)
                {
                    Marshal.ReleaseComObject(folder);
                    throw ex;
                }

                if (pidlMain != IntPtr.Zero)
                {
                    // IShellFolder:
                    Guid iidShellFolder = new
                    Guid("000214E6-0000-0000-C000-000000000046");
                    IShellFolder item = null;

                    try
                    {
                        folder.BindToObject(pidlMain, IntPtr.Zero, ref iidShellFolder, ref item);
                    }
                    catch (Exception ex)
                    {
                        Marshal.ReleaseComObject(folder);
                        Allocator.Free(pidlMain);
                        throw ex;
                    }

                    if (item != null)
                    {
                        string sFileName = Path.GetFileName(file);
                        IntPtr pidlFile = IntPtr.Zero;
                        try
                        {
                            int cParsed = 0;
                            int pdwAttrib = 0;
                            item.ParseDisplayName(IntPtr.Zero, IntPtr.Zero, sFileName, out cParsed, out pidlFile, out pdwAttrib);
                            if (pidlFile != IntPtr.Zero)
                            {
                                getThumbnail(file, pidlFile, item);
                                Allocator.Free(pidlFile);
                            }
                        }
                        catch (Exception ex)
                        {
                            Marshal.ReleaseComObject(folder);
                            Allocator.Free(pidlMain);
                            throw ex;
                        }
                        Marshal.ReleaseComObject(item);
                    }

                    /*if (item != null)
                    {
                        //
                        IEnumIDList idEnum = null;
                        try
                        {
                            item.EnumObjects(
                            IntPtr.Zero,
                            (ESHCONTF.SHCONTF_FOLDERS |
                            ESHCONTF.SHCONTF_NONFOLDERS),
                            ref idEnum);
                        }
                        catch (Exception ex)
                        {
                            Marshal.ReleaseComObject(folder);
                            Allocator.Free(pidlMain);
                            throw ex;
                        }

                        if (idEnum != null)
                        {
                            // start reading the enum:
                            int hRes = 0;
                            IntPtr pidl = IntPtr.Zero;
                            int fetched = 0;
                            bool complete = false;
                            while (!complete)
                            {
                                hRes = idEnum.Next(1, ref pidl, out fetched);
                                if (hRes != 0)
                                {
                                    pidl = IntPtr.Zero;
                                    complete = true;
                                }
                                else
                                {
                                    if (getThumbnail(file, pidl, item))
                                    {
                                        complete = true;
                                    }
                                }
                                if (pidl != IntPtr.Zero)
                                {
                                    Allocator.Free(pidl);
                                }
                            }

                            Marshal.ReleaseComObject(idEnum);
                        }


                        Marshal.ReleaseComObject(item);
                    }*/

                    Allocator.Free(pidlMain);
                }

                Marshal.ReleaseComObject(folder);
            }
            return thumbNail;
        }

        private bool getThumbnail(string file, IntPtr pidl, IShellFolder item)
        {
            IntPtr hBmp = IntPtr.Zero;
            IExtractImage extractImage = null;

            try
            {
                string pidlPath = PathFromPidl(pidl);
                if (Path.GetFileName(pidlPath).ToUpper().Equals(Path.GetFileName(file).ToUpper()))
                {
                    // we have the item: 
                    IUnknown iunk = null;
                    int prgf = 0;
                    Guid iidExtractImage = new Guid("BB2E617C-0920-11d1-9A0B-00C04FC2D6C1");
                    item.GetUIObjectOf(IntPtr.Zero, 1, ref pidl, ref iidExtractImage, out prgf, ref iunk);
                    extractImage = (IExtractImage)iunk;

                    if (extractImage != null)
                    {
                        //Got an IExtractImage object!
                        SIZE sz = new SIZE();
                        sz.cx = desiredSize.Width;
                        sz.cy = desiredSize.Height;
                        StringBuilder location = new StringBuilder(260, 260);
                        int priority = 0;
                        int requestedColourDepth = 32;
                        EIEIFLAG flags = EIEIFLAG.IEIFLAG_ASPECT | EIEIFLAG.IEIFLAG_SCREEN;
                        int uFlags = (int)flags;

                        try
                        {
                            extractImage.GetLocation(location, location.Capacity, ref priority, ref sz, requestedColourDepth, ref uFlags);
                        } catch {}

                        extractImage.Extract(out hBmp);
                        if (hBmp != IntPtr.Zero)
                        {
                            // create the image object:
                            thumbNail = System.Drawing.Bitmap.FromHbitmap(hBmp);
                            // is thumbNail owned by the Bitmap?
                        }

                        Marshal.ReleaseComObject(extractImage);
                        extractImage = null;
                    }
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (Exception ex)
            {
                if (hBmp != IntPtr.Zero)
                {
                    UnManagedMethods.DeleteObject(hBmp);
                }
                if (extractImage != null)
                {
                    Marshal.ReleaseComObject(extractImage);
                }
                throw ex;
            }
        }

        private string PathFromPidl(IntPtr pidl)
        {
            StringBuilder path = new StringBuilder(260, 260);
            int result = UnManagedMethods.SHGetPathFromIDList(pidl, path);
            if (result == 0)
            {
                return string.Empty;
            }
            else
            {
                return path.ToString();
            }
        }

        private IShellFolder getDesktopFolder
        {
            get
            {
                IShellFolder ppshf;
                int r = UnManagedMethods.SHGetDesktopFolder(out ppshf);
                return ppshf;
            }
        }
        #endregion

        #region Constructor, Destructor, Dispose
        public ThumbnailCreator()
        {
        }

        public void Dispose()
        {
            if (!disposed)
            {
                if (alloc != null)
                {
                    Marshal.ReleaseComObject(alloc);
                }
                alloc = null;

                if (thumbNail != null)
                {
                    thumbNail.Dispose();
                }

                disposed = true;
            }
        }

        ~ThumbnailCreator()
        {
            Dispose();
        }
        #endregion
    }
    #endregion
}

另外，在GTAC上看到官方提供的另外一个C#版，https://solutions.industrysoftware.automation.siemens.com/view.php?sort=desc&q=get+part+preview+image+&file_type=text&i=nx_api3944&k=2&o=0

照顾没有账号的同学，摘录如下：

NX API
Sample NX Open .NET C# program : create bitmap from selected part preview
Note: 

GTAC provides programming examples for illustration only, and assumes that you are familiar 
with the programming language being demonstrated and the tools used to create and debug procedures. 
GTAC support professionals can help explain the functionality of a particular procedure, but we 
will not modify these examples to provide added functionality or construct procedures to meet your specific needs.



// Shows existing preview image from work part or selected part
// and also works external with 'run_journal'
using System;
using System.Drawing;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Text;
using System.Windows.Forms;
using NXOpen;

public class Preview : Form
{
    public static Session theSession;
    public static Part wp;
    public static ListingWindow lw;

    private System.Windows.Forms.Button preview_btn;
    private System.Windows.Forms.PictureBox pictureBox1;
    private System.Windows.Forms.Button close_btn;
    private System.Windows.Forms.Button load_btn;
    private System.Windows.Forms.Button save_btn;
    private TextBox textRelease;

    public Preview()
    {
        InitializeComponent();
    }

    [STAThread]
    public static void Main(string[] args)
    {
        try
        {
            theSession = Session.GetSession();
            
            wp = theSession.Parts.Work;
            lw = theSession.ListingWindow;

            Preview preview = new Preview();
            preview.ShowDialog();
        }
        catch (NXException ex)
        {
            MessageBox.Show(ex.Message);
            Console.WriteLine(ex.Message);
        }

    }

    private void getPreview(Part prt)
    {
        BasePart.HistoryEventInformation[] hInfo = prt.GetHistoryInformation();
        string strInfo = "";
        for (int i = 0; i < hInfo.Length; i++)
        {
            strInfo += hInfo[i] + "\r\n";
        }
        textRelease.Text = strInfo;

        int width = 0;
        int height = 0;
        int[] pixels = null;

        prt.GetPreviewImage(out width, out height, out pixels);
        if (width > 0 && height > 0)
        {
            Bitmap image1 = createBitmap(width, height, pixels);
            pictureBox1.Image = image1;
            save_btn.Enabled = true;
        }
        else MessageBox.Show("Part has no valid preview", "Information");
    }

    private Bitmap createBitmap(int w, int h, int[] px)
    {
        //lw.WriteLine("Bitmap Image Size: " + w.ToString() + "x" + h.ToString());
        Bitmap bm = new Bitmap(w, h);

        for (int y = 0; y < h; y++)
        {
            for (int x = 0; x < w; x++)
            {
                int pixel = px[y * w + x];
                Color col1 = Color.FromArgb(pixel);
                Color col2 = Color.FromArgb(255, col1);
                //lw.WriteLine(col2.ToString());
                bm.SetPixel(x, y, col2);
            }
        }

        return bm;
    }

    public static DialogResult select_part_file(ref String filename)
    {
        OpenFileDialog ofd = new OpenFileDialog();
        DialogResult result;

        ofd.Title = "Choose NX part file";
        ofd.AddExtension = true;
        ofd.DefaultExt = "prt";
        ofd.Filter = "NX Part files (*.prt)|*.prt|All files (*.*)|*.*";
        ofd.FilterIndex = 1;
        ofd.ShowHelp = true;

        // start browsing at current folder, uncomment for any other default directory
        // ofd.InitialDirectory = GetEnvironmentVariable("UGII_BASE_DIR");
        // ofd.InitialDirectory = GetEnvironmentVariable("UGII_BASE_DIR") + "\Moldwizard";
        // ofd.InitialDirectory = "c:\mypath1\mypath2";
        result = ofd.ShowDialog();
        filename = ofd.FileName;
        ofd.Dispose();
        return result;
    }

    private void preview_btn_Click(object sender, EventArgs e)
    {
        if (wp == null)
        {
            MessageBox.Show("No Part", "Information");
            return;
        }
        else
        {
            getPreview(wp);
        }
    }

    private void load_btn_Click(object sender, EventArgs e)
    {
        String filename = "";
        if (select_part_file(ref filename) == DialogResult.OK)
        {
            PartLoadStatus loadStatus = null;
            int failCount = 0;

            Part mypart = theSession.Parts.Open(filename, out loadStatus);

            if (loadStatus.NumberUnloadedParts > 0)
                failCount = reportLoadStatus(loadStatus);
            else
            {
                getPreview(mypart);
                mypart.Close(BasePart.CloseWholeTree.True, BasePart.CloseModified.CloseModified, null);
            }
        }
    }

    public static int reportLoadStatus(PartLoadStatus loadStatus)
    {

        lw.Open();

        int counter = 0;

        do
        {

            string file = loadStatus.GetPartName(counter);
            string failure = loadStatus.GetStatusDescription(counter);
            int statusCode = loadStatus.GetStatus(counter);
            MessageBox.Show("File: " + file + "\nCode: " + statusCode + "\nStatus: " + failure, "Unloaded Part");

            counter += 1;
        }
        while (!(counter == loadStatus.NumberUnloadedParts));


        return counter;
    }

    private void save_btn_Click(object sender, EventArgs e)
    {
        SaveFileDialog save = new SaveFileDialog();
        save.Filter = "Bitmap File(*.bmp)|*.bmp";
        if (save.ShowDialog() == DialogResult.OK)
        {
            pictureBox1.Image.Save(save.FileName, System.Drawing.Imaging.ImageFormat.Bmp);
        }
    }

    private void close_btn_Click(object sender, EventArgs e)
    {
        Close();
    }

    private void InitializeComponent()
    {
        this.preview_btn = new System.Windows.Forms.Button();
        this.pictureBox1 = new System.Windows.Forms.PictureBox();
        this.close_btn = new System.Windows.Forms.Button();
        this.load_btn = new System.Windows.Forms.Button();
        this.save_btn = new System.Windows.Forms.Button();
        this.textRelease = new System.Windows.Forms.TextBox();
        ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit();
        this.SuspendLayout();
        // 
        // preview_btn
        // 
        this.preview_btn.Location = new System.Drawing.Point(14, 481);
        this.preview_btn.Name = "preview_btn";
        this.preview_btn.Size = new System.Drawing.Size(75, 23);
        this.preview_btn.TabIndex = 0;
        this.preview_btn.Text = "Work Part";
        this.preview_btn.UseVisualStyleBackColor = true;
        this.preview_btn.Click += new System.EventHandler(this.preview_btn_Click);
        // 
        // pictureBox1
        // 
        this.pictureBox1.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
        this.pictureBox1.Location = new System.Drawing.Point(14, 12);
        this.pictureBox1.Name = "pictureBox1";
        this.pictureBox1.Size = new System.Drawing.Size(534, 400);
        this.pictureBox1.SizeMode = System.Windows.Forms.PictureBoxSizeMode.Zoom;
        this.pictureBox1.TabIndex = 1;
        this.pictureBox1.TabStop = false;
        // 
        // close_btn
        // 
        this.close_btn.Location = new System.Drawing.Point(473, 481);
        this.close_btn.Name = "close_btn";
        this.close_btn.Size = new System.Drawing.Size(75, 23);
        this.close_btn.TabIndex = 2;
        this.close_btn.Text = "Close";
        this.close_btn.UseVisualStyleBackColor = true;
        this.close_btn.Click += new System.EventHandler(this.close_btn_Click);
        // 
        // load_btn
        // 
        this.load_btn.Location = new System.Drawing.Point(95, 481);
        this.load_btn.Name = "load_btn";
        this.load_btn.Size = new System.Drawing.Size(75, 23);
        this.load_btn.TabIndex = 3;
        this.load_btn.Text = "Load Part";
        this.load_btn.UseVisualStyleBackColor = true;
        this.load_btn.Click += new System.EventHandler(this.load_btn_Click);
        // 
        // save_btn
        // 
        this.save_btn.Enabled = false;
        this.save_btn.Location = new System.Drawing.Point(191, 481);
        this.save_btn.Name = "save_btn";
        this.save_btn.Size = new System.Drawing.Size(75, 23);
        this.save_btn.TabIndex = 3;
        this.save_btn.Text = "Save BMP";
        this.save_btn.UseVisualStyleBackColor = true;
        this.save_btn.Click += new System.EventHandler(this.save_btn_Click);
        // 
        // textRelease
        // 
        this.textRelease.BackColor = System.Drawing.SystemColors.Control;
        this.textRelease.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
        this.textRelease.Location = new System.Drawing.Point(14, 418);
        this.textRelease.Multiline = true;
        this.textRelease.Name = "textRelease";
        this.textRelease.ScrollBars = System.Windows.Forms.ScrollBars.Vertical;
        this.textRelease.Size = new System.Drawing.Size(534, 57);
        this.textRelease.TabIndex = 4;
        // 
        // Preview
        // 
        this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
        this.ClientSize = new System.Drawing.Size(563, 516);
        this.Controls.Add(this.load_btn);
        this.Controls.Add(this.save_btn);
        this.Controls.Add(this.close_btn);
        this.Controls.Add(this.pictureBox1);
        this.Controls.Add(this.preview_btn);
        this.Controls.Add(this.textRelease);
        this.Name = "Preview";
        this.Text = "NX Part Preview";
        ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit();
        this.ResumeLayout(false);
        this.PerformLayout();

    }

}