protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider provider)
        {
            using (Form form1 = new Form())
            {
                form1.Text = "FormCollection Visualizer";
                form1.StartPosition = FormStartPosition.WindowsDefaultLocation;
                form1.SizeGripStyle = SizeGripStyle.Auto;
                form1.ShowInTaskbar = false;
                form1.ShowIcon = false;

                DataTable dt;

                using (Stream stream = provider.GetData())
                {
                    BinaryFormatter bformatter = new BinaryFormatter();

                    dt = (DataTable)bformatter.Deserialize(stream);

                    stream.Close();
                }

                DataGridView gridView = new DataGridView();
                gridView.Dock = DockStyle.Fill;

                form1.Controls.Add(gridView);

                gridView.DataSource = dt;

                windowService.ShowDialog(form1);
            }
        }

        protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
        {
            Stream pixbuf_stream = objectProvider.GetData();
            BinaryReader reader = new BinaryReader (pixbuf_stream);

            bool has_alpha;
            int bits_per_sample, width, height, rowstride;
            Gdk.Pixbuf pixbuf;

            has_alpha = reader.ReadBoolean ();
            bits_per_sample = reader.ReadInt32 ();
            width = reader.ReadInt32 ();
            height = reader.ReadInt32 ();
            rowstride = reader.ReadInt32 ();

            int size = height * rowstride;

            byte[] pixbuf_data = new byte [size];

            reader.Read (pixbuf_data, 0, size);

            pixbuf = new Pixbuf (Gdk.Colorspace.Rgb, has_alpha, bits_per_sample, width, height);

            Marshal.Copy (pixbuf_data, 0, pixbuf.Pixels, size);

            PixbufWindow win = new PixbufWindow ("Pixbuf Visualizer", pixbuf);

            win.Show ();
        }

        protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
        {
            if (windowService == null)
                throw new ArgumentNullException("windowService");
            if (objectProvider == null)
                throw new ArgumentNullException("objectProvider");

            DataTable dt = objectProvider.GetObject() as DataTable;

            if (dt != null)
            {
                using (FormMainDataSet main = new FormMainDataSet())
                {
                    main.Init(dt, objectProvider.IsObjectReplaceable, "DataRow Visualizer");

                    DialogResult dr = windowService.ShowDialog(main);

                    if (objectProvider.IsObjectReplaceable && dr == DialogResult.OK)
                    {
                        /// DataRow is not serializable, so we serialize the item array
                        /// in the TransferData override of the DataRowVisualizerObjectSource we deserialize the itemArray
                        /// and update the values on the original DataRow
                        objectProvider.TransferData(StreamSerializer.ObjectToStream(null, dt.Rows[0].ItemArray));
                    }
                }
            }
        }

        protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
        {
            try
            {
                var obj = objectProvider.GetData();
                var modelNode = new M2ModelDialogDebuggerVisualizerService().DeserializeDataFromStream<ModelNode>(obj);

                var form = new Form
                {
                    ClientSize = new Size(800, 600),
                    FormBorderStyle = FormBorderStyle.FixedToolWindow,
                };

                var treeView = new TreeView();
                treeView.Parent = form;
                treeView.Dock = DockStyle.Fill;

                InitNodes(treeView.Nodes, modelNode);
                treeView.ExpandAll();

                windowService.ShowDialog(form);
            }
            catch (Exception e)
            {
                // TODO
                throw;
            }
        }

        protected override void Show(IDialogVisualizerService p_windowService, IVisualizerObjectProvider p_objectProvider)
        {
            try
            {
                // Get data from VisualizerBase as Stream
                using (Stream objStreamData = p_objectProvider.GetData())
                {
                    BinaryFormatter bf = new BinaryFormatter();

                    // Create instance from that stream
                    BaseTable objBaseVisualizer = (BaseTable)bf.Deserialize(objStreamData);

                    // We get the first table in list (since we only use this one in DataTable visualizer)
                    VisualizerBaseTable objTable = objBaseVisualizer.MyTableToVisualize[0];

                    // We create new Form
                    VisualizerForm frmVisualizerForm = new VisualizerForm(objTable);

                    // And walla
                    frmVisualizerForm.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                UiHelper.MyMessageBox("Error while opening " + UiHelper.APP_NAME + " - DataTable Visualizer", ex);
            }
        }

        protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
        {
            try
            {
                if (windowService == null)
                {
                    throw new ArgumentNullException("windowService");
                }
                if (objectProvider == null)
                {
                    throw new ArgumentNullException("objectProvider");
                }

                object data = (object)objectProvider.GetObject();
                System.Data.DataSet ds = data as System.Data.DataSet;
                if (ds == null)
                {
                    throw new ArgumentException("Only DataSets can be visualized with the ExtendedDataSetVisualizer");
                }

                using (ExtendedDataSetVisualizerWin win = new ExtendedDataSetVisualizerWin(ds))
                {
                    windowService.ShowDialog(win);
                }
            }
            catch (System.Exception rExc)
            {
                MessageBox.Show(rExc.Message);
            }
        }

 public VisualizerDataSource(IVisualizerObjectProvider objectProvider)
 {
     DataTable = new DataTable();
     var data = ReadData(objectProvider);
     AddColumns(data);
     AddRows(data);
 }

        protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
        {
            var image = (Bitmap) objectProvider.GetObject();
            
            var dialogTitle = String.Format("Width: {0}, Height: {1}, Format: {2}",
                                               image.Width, image.Height, image.PixelFormat);

            var form = new Form
                {
                    Text = dialogTitle,
                    ClientSize = new Size(image.Width, image.Height),
                    FormBorderStyle = FormBorderStyle.FixedToolWindow,
                };

            var pictureBox = new PictureBox
                {
                    Image = image,
                    Dock = DockStyle.Fill,
                    Parent = form,
                };

            pictureBox.MouseMove += (s, a) =>
                {
                    form.Text = String.Format("{0}, RGB({1})={2}",
                        dialogTitle, a.Location, image.GetPixel(a.Location.X, a.Location.Y));
                };

            windowService.ShowDialog(form);
        }

        protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider provider)
        {
            using (Form form1 = new Form())
            {
                form1.Paint += new PaintEventHandler(form1_Paint);

                form1.Text = "Font Visualizer";

                font = (Font)provider.GetObject();

                form1.StartPosition = FormStartPosition.WindowsDefaultLocation;
                form1.SizeGripStyle = SizeGripStyle.Auto;
                form1.ShowInTaskbar = false;
                form1.ShowIcon = false;

                Graphics formGraphics = form1.CreateGraphics();

                var size = formGraphics.MeasureString(font.Name, font);

                form1.Width = (int)size.Width + 100;
                form1.Height = (int)size.Height + 100;

                windowService.ShowDialog(form1);
            }
        }

 protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
 {
     StringBuilder sb = new StringBuilder();
     var ilBytes = ((ILDelta)objectProvider.GetObject()).Value;
     var viewer = new TextViewer(ilBytes.GetMethodIL(), "IL");
     viewer.ShowDialog();
 }

        protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
        {
            var bitmap = (Bitmap)objectProvider.GetObject();

            if (bitmap == null)
                throw new NullReferenceException("Make sure your Bitmap is not null.");

            var form = new Form
            {
                Text = String.Format("ImageView - W: {0}px  H: {1}px", bitmap.Width, bitmap.Height),
                ClientSize = new Size(480, 320),
                FormBorderStyle = FormBorderStyle.Sizable,
                ShowInTaskbar = false,
                ShowIcon = false
            };

            var pictureBox = new PictureBox
            {
                SizeMode = PictureBoxSizeMode.Zoom,
                Image = bitmap,
                Parent = form,
                Dock = DockStyle.Fill
            };

            form.ShowDialog();
        }

        protected override void Show(IDialogVisualizerService windowService,
                                     IVisualizerObjectProvider objectProvider)
        {
            var board = (objectProvider.GetObject()) as Board;

            new GoBoardForm(board).ShowDialog();
        }

        protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
        {
            if (windowService == null)
                throw new ArgumentNullException("windowService");
            if (objectProvider == null)
                throw new ArgumentNullException("objectProvider");

            // TODO: 取得要顯示其視覺化檢視的物件。
            //       將 objectProvider.GetObject() 的結果轉型為
            //       要視覺化的物件型別。
            var data = (Image)objectProvider.GetObject();

            // TODO: 顯示您的物件檢視。
            //       以自己的自訂表單或控制項取代 displayForm。
            using (Form displayForm = new Form
            {
                Text = string.Format("Width: {0}, Height: {1} Format:{2}", data.Width, data.Height, data.PixelFormat),
                ClientSize = new Size(data.Width, data.Height),
                FormBorderStyle = FormBorderStyle.FixedToolWindow,
                StartPosition = FormStartPosition.CenterScreen,
            }
                  )
            {
                PictureBox box = new PictureBox { Image = data, Dock = DockStyle.Fill };
                displayForm.Controls.Add(box);
                windowService.ShowDialog(displayForm);
            }
        }

        protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
        {
            if (windowService != null)
            {
                if (objectProvider != null)
                {
                    var obj = objectProvider.GetObject() as QueryData;
                    //  flag1 = obj == null;
                    if (obj != null)
                    {
                        var form = new EfVisualizerForm();
                        if (!string.IsNullOrEmpty(obj.ExceptionMessage))
                        {
                            form.SetDebugText(string.Format("Error:{0}{1}", Environment.NewLine, obj.ExceptionMessage));
                        }
                        else
                        {
                            form.SetDebugText(obj.SQLCommand);
                        }
                        DialogResult dialogResult = windowService.ShowDialog(form);

                    }
                }
                else
                {
                    throw new ArgumentNullException("objectProvider");
                }
            }
            else
            {
                throw new ArgumentNullException("windowService");
            }
        }

        /// <summary>
        /// Contains the code that actually creates the ChromeVisualizer (by starting its process)
        /// </summary>
        /// <param name="windowService"></param>
        /// <param name="objectProvider"></param>
        protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
        {
            // Get the HTML we want to visualize
            string html = objectProvider.GetObject().ToString();

            // Get temp file path
            string htmlFilePath = Path.GetTempFileName() + ".html";

            try
            {
                // Try to write it out
                File.WriteAllText(htmlFilePath, html, Encoding.UTF8);
            }
            catch (Exception exc)
            {
                // Report it to the user
                MessageBox.Show("Failed to save HTML to a temporary text file: " + exc.Message);
                return;
            }

            // Create a new process to launch our chrome visualizer
            Process process = new Process();

            // Link to the ChromeVisualizer.exe file
            process.StartInfo.FileName = chromeVisualizerPath;

            // Pass the HTML temp file path as argument
            process.StartInfo.Arguments = htmlFilePath;

            // Maximize the window
            process.StartInfo.WindowStyle = ProcessWindowStyle.Maximized;

            try
            {
                // Finally, start the process!
                process.Start();
            }
            catch (Exception exc)
            {
                // Report it to the user
                MessageBox.Show("Failed to start the Chrome Visualizer executable: " + exc.Message);
                return;
            }

            // Wait for user to close window
            process.WaitForExit();

            try
            {
                // Finally, try to delete the temp file
                File.Delete(htmlFilePath);
            }
            catch (Exception exc)
            {
                // Report it to the user
                MessageBox.Show("Failed to delete the temporary HTML file: " + exc.Message);
                return;
            }
        }

 protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
 {
     SerializedProxy data = (SerializedProxy)objectProvider.GetObject ();
     //MessageBox.Show(data.ProxyType.FullName);
     AopProxyVisualizerForm form = new AopProxyVisualizerForm();
     form.Proxy = data;
     windowService.ShowDialog(form);
 }

 /// <summary>
 /// 表示
 /// </summary>
 /// <param name="windowService"></param>
 /// <param name="objectProvider"></param>
 protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
 {
     using (MatrixVisualizerForm displayForm = new MatrixVisualizerForm())
     {
         displayForm.SetMatrix(objectProvider.GetObject() as KrdLab.Lisys.Matrix);
         windowService.ShowDialog(displayForm);
     }
 }

 protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
 {
     var window = new Window
     {
         Content = new View((IEnumerable<object>) objectProvider.GetObject())
     };
     window.ShowDialog();
 }

 protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
 {
     MainForm preview = new MainForm();
     DataTable dt = null;
     dt = (DataTable)objectProvider.GetObject();
     object rowObject = dt.Rows[dt.Rows.Count - 1][0];
     preview.ShowData(dt, rowObject.ToString());
 }

        protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
        {
            var fixMessageString = objectProvider.GetObject().ToString();

            var directoryPath = Path.GetDirectoryName(Uri.UnescapeDataString(new System.Uri(Assembly.GetExecutingAssembly().CodeBase).AbsolutePath));

            FixMessageVisualizerDialog.Show(fixMessageString, new ConventionBasedFixDictionarySource(directoryPath), null);
        }