using System;  
 using System.Diagnostics;  
 using System.IO;  
 using System.Management;  
 using System.Windows.Forms;  
 
 namespace PrintPreview  
 {  
     public partial class Banner : UserControl  
     {  
         public Banner()  
         {  
             InitializeComponent();  
             SetupBannerAd();  
         }  
 
         public void SetupBannerAd()  
         {  
             if (Process.GetCurrentProcess().ProcessName != "devenv")  
             {  
                 adRotator.Url = new Uri(new DirectoryInfo(@"..\..\Resources\bannerad_offline.html").FullName);  
                 if (IsNetworkAlive())  
                 {  
                     adRotator.Navigate("http://gis.thinkgeo.com/Default.aspx?tabid=640&random=" + Guid.NewGuid().ToString());  
                     adsRotatorTimer.Start();  
                 }  
             }  
         }  
 
         private static bool IsNetworkAlive()  
         {  
             ObjectQuery objectQuery = new ObjectQuery("select * from Win32_NetworkAdapter where NetConnectionStatus=2");  
             ManagementObjectSearcher searcher = null;  
             try  
             {  
                 searcher = new ManagementObjectSearcher(objectQuery);  
 
                 return (searcher.Get().Count > 0);  
             }  
             finally  
             {  
                 if (searcher != null)  
                 {  
                     searcher.Dispose();  
                 }  
             }  
         }  
 
         private void adsRotatorTimer_Tick(object sender, EventArgs e)  
         {  
             adRotator.Navigate("http://gis.thinkgeo.com/Default.aspx?tabid=640&random=" + Guid.NewGuid().ToString());  
         }  
     }  
 }

 using System;  
 using System.Collections.Generic;  
 using System.ComponentModel;  
 using System.Data;  
 using System.Drawing;  
 using System.Text;  
 using System.Windows.Forms;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace PrintPreview  
 {  
     public partial class CompassPrinterLayerProperty : Form  
     {  
         CompassPrinterLayer layer = null;  
 
         public CompassPrinterLayerProperty(CompassPrinterLayer layer)  
         {  
             InitializeComponent();  
 
             this.layer = layer;  
         }  
 
 
         private void Window_Load(object sender, EventArgs e)  
         {  
             LoadLayerProperties();  
             LoadResize();  
             LoadDrag();  
         }  
 
         private void btnOK_Click(object sender, EventArgs e)  
         {  
             SetLayerProperties();  
             SetResize();  
             SetDrag();  
             Close();  
 
             DialogResult = DialogResult.OK;  
         }  
 
         private void LoadLayerProperties()  
         {  
             if (layer.NeedleImage != null)  
             {  
                 txtPath.Text = layer.NeedleImage.PathFilename;  
             }  
         }  
 
         private void SetLayerProperties()  
         {  
             GeoImage image = new GeoImage(txtPath.Text);  
             layer.NeedleImage = image;  
 
             layer.Open();  
             PointShape centerPoint = layer.GetPosition().GetCenterPoint();  
             layer.SetPosition(image.GetWidth(), image.GetHeight(), centerPoint, PrintingUnit.Point);  
         }  
 
         private void LoadResize()  
         {  
             switch (layer.PrinterResizeMode)  
             {  
                 case PrinterResizeMode.Fixed:  
                     rbtnResizeFixed.Checked = true;  
                     break;  
                 case PrinterResizeMode.MaintainAspectRatio:  
                     rbtnResizeMaintainRaio.Checked = true;  
                     break;  
                 case PrinterResizeMode.Resizable:  
                     rbtnResize.Checked = true;  
                     break;  
                 default:  
                     break;  
             }  
         }  
 
         private void SetResize()  
         {  
             if (rbtnResize.Checked)  
             {  
                 layer.PrinterResizeMode = PrinterResizeMode.Resizable;  
             }  
             else if (rbtnResizeFixed.Checked)  
             {  
                 layer.PrinterResizeMode = PrinterResizeMode.Fixed;  
             }  
             else if (rbtnResizeMaintainRaio.Checked)  
             {  
                 layer.PrinterResizeMode = PrinterResizeMode.MaintainAspectRatio;  
             }  
         }  
 
         private void LoadDrag()  
         {  
             switch (layer.PrinterDragMode)  
             {  
                 case PrinterDragMode.Fixed:  
                     rbtnDragFixed.Checked = true;  
                     break;  
                 case PrinterDragMode.Dragable:  
                     rbtnDraggable.Checked = true;  
                     break;  
                 default:  
                     break;  
             }  
         }  
 
         private void SetDrag()  
         {  
             if (rbtnDragFixed.Checked)  
             {  
                 layer.PrinterDragMode = PrinterDragMode.Fixed;  
             }  
             else if (rbtnDraggable.Checked)  
             {  
                 layer.PrinterDragMode = PrinterDragMode.Dragable;  
             }  
         }  
 
 
         private void btnBrowse_Click(object sender, EventArgs e)  
         {  
             OpenFileDialog ofd = new OpenFileDialog();  
             ofd.Filter = "All files (*.*)|*.*";  
             ofd.RestoreDirectory = true;  
 
             if (ofd.ShowDialog() == DialogResult.OK)  
             {  
                 txtPath.Text = ofd.FileName;  
             }  
         }  
     }  
 }  
 

 using System;  
 using System.Collections.Generic;  
 using System.ComponentModel;  
 using System.Data;  
 using System.Drawing;  
 using System.Text;  
 using System.Windows.Forms;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace PrintPreview  
 {  
     public partial class DataGridPrinterLayerProperty : Form  
     {  
         DataGridPrinterLayer dataGridPrinterLayer = null;  
 
         public DataGridPrinterLayerProperty(DataGridPrinterLayer dataGridPrinterLayer)  
         {  
             InitializeComponent();  
 
             this.dataGridPrinterLayer = dataGridPrinterLayer;  
         }  
 
 
         private void Window_Load(object sender, EventArgs e)  
         {  
             LoadLayerProperties();  
             LoadResize();  
             LoadDrag();  
         }  
 
         private void btnOK_Click(object sender, EventArgs e)  
         {  
             SetLayerProperties();  
             SetResize();  
             SetDrag();  
             Close();  
 
             DialogResult = DialogResult.OK;  
         }  
 
         private void LoadLayerProperties()  
         {  
             dv.DataSource = dataGridPrinterLayer.DataTable;  
 
             foreach (DataColumn column in dataGridPrinterLayer.DataTable.Columns)  
             {  
                 cbxColumns.Items.Add(column.ColumnName);  
             }  
 
             lbFontSample.Font = Helper .GetFont ( dataGridPrinterLayer.TextFont);  
             lbFontSample.ForeColor = Helper.GetColor(((GeoSolidBrush)dataGridPrinterLayer.TextBrush).Color);  
         }  
 
         private void SetLayerProperties()  
         {  
             dataGridPrinterLayer.DataTable = (DataTable)dv.DataSource;  
 
             dataGridPrinterLayer.TextFont = Helper.GetGeoFont(lbFontSample.Font);  
             ((GeoSolidBrush)dataGridPrinterLayer.TextBrush).Color = Helper.GetGeoColor(lbFontSample.ForeColor);  
         }  
 
         private void LoadResize()  
         {  
             switch (dataGridPrinterLayer.ResizeMode)  
             {  
                 case PrinterResizeMode.Fixed:  
                     rbtnResizeFixed.Checked = true;  
                     break;  
                 case PrinterResizeMode.MaintainAspectRatio:  
                     rbtnResizeMaintainRaio.Checked = true;  
                     break;  
                 case PrinterResizeMode.Resizable:  
                     rbtnResize.Checked = true;  
                     break;  
                 default:  
                     break;  
             }  
         }  
 
         private void SetResize()  
         {  
             if (rbtnResize.Checked)  
             {  
                 dataGridPrinterLayer.ResizeMode = PrinterResizeMode.Resizable;  
             }  
             else if (rbtnResizeFixed.Checked)  
             {  
                 dataGridPrinterLayer.ResizeMode = PrinterResizeMode.Fixed;  
             }  
             else if (rbtnResizeMaintainRaio.Checked)  
             {  
                 dataGridPrinterLayer.ResizeMode = PrinterResizeMode.MaintainAspectRatio;  
             }  
         }  
 
         private void LoadDrag()  
         {  
             switch (dataGridPrinterLayer.DragMode)  
             {  
                 case PrinterDragMode.Fixed:  
                     rbtnDragFixed.Checked = true;  
                     break;  
                 case PrinterDragMode.Dragable:  
                     rbtnDraggable.Checked = true;  
                     break;  
                 default:  
                     break;  
             }  
         }  
 
         private void SetDrag()  
         {  
             if (rbtnDragFixed.Checked)  
             {  
                 dataGridPrinterLayer.DragMode = PrinterDragMode.Fixed;  
             }  
             else if (rbtnDraggable.Checked)  
             {  
                 dataGridPrinterLayer.DragMode = PrinterDragMode.Dragable;  
             }  
         }  
 
         private void btnAdd_Click(object sender, EventArgs e)  
         {  
             DataTable dt = (DataTable)dv.DataSource;  
             string columnName = txtColumnName.Text;  
             if (dt.Columns.Contains(columnName))  
             {  
                 MessageBox.Show("Duplicate Column Name");  
             }  
             else  
             {  
                 dt.Columns.Add(columnName);  
                 txtColumnName.Text = "";  
                 cbxColumns.Items.Add(columnName);  
             }  
         }  
 
         private void btnRemove_Click(object sender, EventArgs e)  
         {  
             DataTable dt = (DataTable)dv.DataSource;  
             string deletingColumnName = cbxColumns.Text;  
 
             if (dt.Columns.Contains(deletingColumnName))  
             {  
                 dt.Columns.Remove(deletingColumnName);  
             }  
         }  
 
         private void btnChangeFont_Click(object sender, EventArgs e)  
         {  
             FontDialog fd = new FontDialog();  
             fd.ShowColor = true;  
             fd.Font = lbFontSample.Font;  
             fd.Color = lbFontSample.ForeColor;  
 
             if (fd.ShowDialog() != DialogResult.Cancel)  
             {  
                 lbFontSample.Font = fd.Font;  
                 lbFontSample.ForeColor = fd.Color;  
             }  
         }  
 
         private void btnCancel_Click(object sender, EventArgs e)  
         {  
             Close();  
         }  
     }  
 }  
 

 using System;  
 using System.Diagnostics;  
 using System.Windows.Forms;  
 using PrintPreview.Properties;  
 
 public partial class Footer : UserControl  
 {  
     public Footer()  
     {  
         InitializeComponent();  
     }  
 
     private void btnProductInformation_Click(object sender, EventArgs e)  
     {  
         Process.Start("http://gis.thinkgeo.com/Default.aspx?tabid=674");  
     }  
 
     private void btnProductInformation_Activate(object sender, EventArgs e)  
     {  
         btnProductInformation.Image = Resources.btn_active_map_suite_products;  
     }  
 
     private void btnProductInformation_Deactivate(object sender, EventArgs e)  
     {  
         btnProductInformation.Image = Resources.btn_inactive_map_suite_products;  
     }  
 
     private void btnSupportCenter_Click(object sender, EventArgs e)  
     {  
         Process.Start("http://gis.thinkgeo.com/supportcenter");  
     }  
 
     private void btnSupportCenter_Activate(object sender, EventArgs e)  
     {  
         btnSupportCenter.Image = Resources.btn_active_support_center;  
     }  
 
     private void btnSupportCenter_Deactivate(object sender, EventArgs e)  
     {  
         btnSupportCenter.Image = Resources.btn_inactive_support_center;  
     }  
 
     private void btnDiscussForum_Click(object sender, EventArgs e)  
     {  
         Process.Start("http://gis.thinkgeo.com/Support/DiscussionForums/tabid/143/afv/topicsview/aff/21/Default.aspx");  
     }  
 
     private void btnDiscussForum_Activate(object sender, EventArgs e)  
     {  
         btnDiscussForum.Image = Resources.btn_active_discussion_forums;  
     }  
 
     private void btnDiscussForum_Deactivate(object sender, EventArgs e)  
     {  
         btnDiscussForum.Image = Resources.btn_inactive_discussion_forums;  
     }  
 
     private void btnWiki_Click(object sender, EventArgs e)  
     {  
         Process.Start("http://wiki.thinkgeo.com/wiki/Map_Suite_Desktop_Edition");  
     }  
 
     private void btnWiki_Activate(object sender, EventArgs e)  
     {  
         btnWiki.Image = Resources.btn_active_thinkgeo_wiki;  
     }  
 
     private void btnWiki_Deactivate(object sender, EventArgs e)  
     {  
         btnWiki.Image = Resources.btn_inactive_thinkgeo_wiki;  
     }  
 
     private void btnContactUs_Click(object sender, EventArgs e)  
     {  
         Process.Start("http://gis.thinkgeo.com/Default.aspx?tabid=147");  
     }  
 
     private void btnContactUs_Activate(object sender, EventArgs e)  
     {  
         btnContactUs.Image = Resources.btn_active_contact_us;  
     }  
 
     private void btnContactUs_Deactivate(object sender, EventArgs e)  
     {  
         btnContactUs.Image = Resources.btn_inactive_contact_us;  
     }  
 }  
 

 using System;  
 using System.Collections.Generic;  
 using System.Text;  
 using System.Drawing;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace PrintPreview  
 {  
     public static class Helper  
     {  
         public static Font GetFont(GeoFont geoFont)  
         {  
             FontStyle style = FontStyle.Regular;  
             switch (geoFont.Style)  
             {  
                 case DrawingFontStyles.Regular:  
                     style = FontStyle.Regular;  
                     break;  
                 case DrawingFontStyles.Bold:  
                     style = FontStyle.Bold;  
                     break;  
                 case DrawingFontStyles.Italic:  
                     style = FontStyle.Italic;  
                     break;  
                 case DrawingFontStyles.Underline:  
                     style = FontStyle.Underline;  
                     break;  
                 case DrawingFontStyles.Strikeout:  
                     style = FontStyle.Strikeout;  
                     break;  
                 default:  
                     break;  
             }  
 
 
             Font font = new Font(geoFont.FontName, geoFont.Size, style);  
 
             return font;  
         }  
 
         public static GeoFont GetGeoFont(Font font)  
         {  
             DrawingFontStyles style = DrawingFontStyles.Regular;  
             switch (font.Style)  
             {  
                 case FontStyle.Bold:  
                     style = DrawingFontStyles.Bold;  
                     break;  
                 case FontStyle.Italic:  
                     style = DrawingFontStyles.Italic;  
                     break;  
                 case FontStyle.Regular:  
                     style = DrawingFontStyles.Regular;  
                     break;  
                 case FontStyle.Strikeout:  
                     style = DrawingFontStyles.Strikeout;  
                     break;  
                 case FontStyle.Underline:  
                     style = DrawingFontStyles.Underline;  
                     break;  
                 default:  
                     break;  
             }  
 
             return new GeoFont(font.FontFamily.Name, font.Size, style);  
         }  
 
         public static Color GetColor(GeoColor geoColor)  
         {  
             return Color.FromArgb(geoColor.AlphaComponent, geoColor.RedComponent, geoColor.GreenComponent, geoColor.BlueComponent);  
         }  
 
         public static GeoColor GetGeoColor(Color color)  
         {  
             return GeoColor.FromArgb(color.A, color.R, color.G, color.B);  
         }  
     }  
 }  
 

 using System;  
 using System.Windows.Forms;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace PrintPreview  
 {  
     public partial class ImagePrinterLayerProperty : Form  
     {  
         ImagePrinterLayer imagePrinterLayer = null;  
 
         public ImagePrinterLayerProperty(ImagePrinterLayer imagePrinterLayer)  
         {  
             InitializeComponent();  
 
             this.imagePrinterLayer = imagePrinterLayer;  
         }  
 
         private void Window_Load(object sender, EventArgs e)  
         {  
             LoadLayerProperties();  
             LoadResize();  
             LoadDrag();  
         }  
 
         private void btnOK_Click(object sender, EventArgs e)  
         {  
             SetLayerProperties();  
             SetResize();  
             SetDrag();  
             Close();  
 
             DialogResult = DialogResult.OK;  
         }  
 
         private void LoadLayerProperties()  
         {  
             txtPath.Text = imagePrinterLayer.Image.PathFilename;  
         }  
 
         private void SetLayerProperties()  
         {  
             GeoImage image = new GeoImage(txtPath.Text);  
             imagePrinterLayer.Image = image;  
 
             imagePrinterLayer.Open();  
             PointShape centerPoint = imagePrinterLayer.GetPosition().GetCenterPoint();  
             imagePrinterLayer.SetPosition(image.GetWidth(), image.GetHeight(), centerPoint, PrintingUnit.Point);  
         }  
 
         private void LoadResize()  
         {  
             switch (imagePrinterLayer.ResizeMode)  
             {  
                 case PrinterResizeMode.Fixed:  
                     rbtnResizeFixed.Checked = true;  
                     break;  
                 case PrinterResizeMode.MaintainAspectRatio:  
                     rbtnResizeMaintainRaio.Checked = true;  
                     break;  
                 case PrinterResizeMode.Resizable:  
                     rbtnResize.Checked = true;  
                     break;  
                 default:  
                     break;  
             }  
         }  
 
         private void SetResize()  
         {  
             if (rbtnResize.Checked)  
             {  
                 imagePrinterLayer.ResizeMode = PrinterResizeMode.Resizable;  
             }  
             else if (rbtnResizeFixed.Checked)  
             {  
                 imagePrinterLayer.ResizeMode = PrinterResizeMode.Fixed;  
             }  
             else if (rbtnResizeMaintainRaio.Checked)  
             {  
                 imagePrinterLayer.ResizeMode = PrinterResizeMode.MaintainAspectRatio;  
             }  
         }  
 
         private void LoadDrag()  
         {  
             switch (imagePrinterLayer.DragMode)  
             {  
                 case PrinterDragMode.Fixed:  
                     rbtnDragFixed.Checked = true;  
                     break;  
                 case PrinterDragMode.Dragable:  
                     rbtnDraggable.Checked = true;  
                     break;  
                 default:  
                     break;  
             }  
         }  
 
         private void SetDrag()  
         {  
             if (rbtnDragFixed.Checked)  
             {  
                 imagePrinterLayer.DragMode = PrinterDragMode.Fixed;  
             }  
             else if (rbtnDraggable.Checked)  
             {  
                 imagePrinterLayer.DragMode = PrinterDragMode.Dragable;  
             }  
         }  
 
         private void btnBrowse_Click(object sender, EventArgs e)  
         {  
             OpenFileDialog ofd = new OpenFileDialog();  
             ofd.Filter = "All files (*.*)|*.*";  
             ofd.RestoreDirectory = true;  
 
             if (ofd.ShowDialog() == DialogResult.OK)  
             {  
                 txtPath.Text = ofd.FileName;  
             }  
         }  
 
     }  
 }  
 

 using System;  
 using System.Collections.Generic;  
 using System.ComponentModel;  
 using System.Data;  
 using System.Drawing;  
 using System.Text;  
 using System.Windows.Forms;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace PrintPreview  
 {  
     public partial class LabelPrinterLayerProperty : Form  
     {  
         LabelPrinterLayer labelPrinterLayer = null;  
 
         public LabelPrinterLayerProperty(LabelPrinterLayer labelPrinterLayer)  
         {  
             InitializeComponent();  
 
             this.labelPrinterLayer = labelPrinterLayer;  
         }  
 
         private void LabelPrinterLayerProperty_Load(object sender, EventArgs e)  
         {  
             LoadLayerProperties();  
             LoadResize();  
             LoadDrag();  
         }  
 
         private void btnOK_Click(object sender, EventArgs e)  
         {  
             SetLayerProperties();  
             SetResize();  
             SetDrag();  
             Close();  
 
             DialogResult = DialogResult.OK;  
         }  
 
         private void LoadLayerProperties()  
         {  
             txtText.Text = labelPrinterLayer.Text;  
             lbFontSample.Font = GetFont(labelPrinterLayer.Font);  
             lbFontSample.ForeColor = GetColor(((GeoSolidBrush)labelPrinterLayer.TextBrush).Color);  
 
             if (labelPrinterLayer.PrinterWrapMode == PrinterWrapMode.WrapText)  
             {  
                 chkEnableWrapText.Checked = true;  
             }  
             else  
             {  
                 chkEnableWrapText.Checked = false;  
             }  
         }  
 
         private void SetLayerProperties()  
         {  
             labelPrinterLayer.Text = txtText.Text;  
             labelPrinterLayer.Font = GetGeoFont(lbFontSample.Font);  
             ((GeoSolidBrush)labelPrinterLayer.TextBrush).Color = GetGeoColor(lbFontSample.ForeColor);  
 
             if (chkEnableWrapText.Checked)  
             {  
                 labelPrinterLayer.PrinterWrapMode = PrinterWrapMode.WrapText;  
             }  
             else  
             {  
                 labelPrinterLayer.PrinterWrapMode = PrinterWrapMode.AutoSizeText;  
             }  
         }  
 
         private Font GetFont(GeoFont geoFont)  
         {  
             return new Font(geoFont.FontName, geoFont.Size);  
         }  
 
         private GeoFont GetGeoFont(Font font)  
         {  
             return new GeoFont(font.FontFamily.Name, font.Size);  
         }  
 
         private Color GetColor(GeoColor geoColor)  
         {  
             return Color.FromArgb(geoColor.AlphaComponent, geoColor.RedComponent, geoColor.GreenComponent, geoColor.BlueComponent);  
         }  
 
         private GeoColor GetGeoColor(Color color)  
         {  
             return GeoColor.FromArgb(color.A, color.R, color.G, color.B);  
         }  
 
         private void btnChangeFont_Click(object sender, EventArgs e)  
         {  
             FontDialog fd = new FontDialog();  
             fd.ShowColor = true;  
             fd.Font = lbFontSample.Font;  
             fd.Color = lbFontSample.ForeColor;  
 
             if (fd.ShowDialog() != DialogResult.Cancel)  
             {  
                 lbFontSample.Font = fd.Font;  
                 lbFontSample.ForeColor = fd.Color;  
             }  
         }  
 
         private void LoadResize()  
         {  
             switch (labelPrinterLayer.ResizeMode)  
             {  
                 case PrinterResizeMode.Fixed:  
                     rbtnResizeFixed.Checked = true;  
                     break;  
                 case PrinterResizeMode.MaintainAspectRatio:  
                     rbtnResizeMaintainRaio.Checked = true;  
                     break;  
                 case PrinterResizeMode.Resizable:  
                     rbtnResize.Checked = true;  
                     break;  
                 default:  
                     break;  
             }  
         }  
 
         private void SetResize()  
         {  
             if (rbtnResize.Checked)  
             {  
                 labelPrinterLayer.ResizeMode = PrinterResizeMode.Resizable;  
             }  
             else if (rbtnResizeFixed.Checked)  
             {  
                 labelPrinterLayer.ResizeMode = PrinterResizeMode.Fixed;  
             }  
             else if (rbtnResizeMaintainRaio.Checked)  
             {  
                 labelPrinterLayer.ResizeMode = PrinterResizeMode.MaintainAspectRatio;  
             }  
         }  
 
         private void LoadDrag()  
         {  
             switch (labelPrinterLayer.DragMode)  
             {  
                 case PrinterDragMode.Fixed:  
                     rbtnDragFixed.Checked = true;  
                     break;  
                 case PrinterDragMode.Dragable:  
                     rbtnDraggable.Checked = true;  
                     break;  
                 default:  
                     break;  
             }  
         }  
 
         private void SetDrag()  
         {  
             if (rbtnDragFixed.Checked)  
             {  
                 labelPrinterLayer.DragMode = PrinterDragMode.Fixed;  
             }  
             else if (rbtnDraggable.Checked)  
             {  
                 labelPrinterLayer.DragMode = PrinterDragMode.Dragable;  
             }  
         }  
     }  
 }  
 

 using System;  
 using System.Collections.Generic;  
 using System.ComponentModel;  
 using System.Data;  
 using System.Drawing;  
 using System.Text;  
 using System.Windows.Forms;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace PrintPreview  
 {  
     public partial class MapPrinterLayerProperty : Form  
     {  
         MapPrinterLayer mapPrinterLayer = null;  
         bool isEditing = false;  
 
         public MapPrinterLayerProperty(MapPrinterLayer mapPrinterLayer)  
         {  
             InitializeComponent();  
 
             this.mapPrinterLayer = mapPrinterLayer;  
         }  
 
         private void Window_Load(object sender, EventArgs e)  
         {  
             LoadLayerProperties();  
             LoadResize();  
             LoadDrag();  
         }  
 
         private void btnOK_Click(object sender, EventArgs e)  
         {  
             SetLayerProperties();  
             SetResize();  
             SetDrag();  
             Close();  
 
             DialogResult = DialogResult.OK;  
         }  
 
         private void LoadLayerProperties()  
         {  
             if (mapPrinterLayer.Layers.Count > 0  
                 && mapPrinterLayer.Layers[0].GetType() == typeof(ShapeFileFeatureLayer))  
             {  
                 txtPath.Text = ((ShapeFileFeatureLayer)mapPrinterLayer.Layers[0]).ShapePathFileName;  
                 isEditing = true;  
             }  
 
             if (isEditing)  
             {  
                 txtPath.Enabled = false;  
                 btnBrowse.Enabled = false;  
             }  
         }  
 
         private void SetLayerProperties()  
         {  
             ShapeFileFeatureLayer shapeLayer = new ShapeFileFeatureLayer(txtPath.Text);  
             shapeLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             shapeLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.Country1;  
             shapeLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = new LineStyle(new GeoPen(GeoColor.SimpleColors.Black, 1));  
             shapeLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = PointStyles.Capital1;  
             shapeLayer.Open();  
 
             if (isEditing)  
             {  
                 mapPrinterLayer.Layers.RemoveAt(0);  
             }  
             else  
             {  
                 mapPrinterLayer.SetPosition(500, 500, 0, 0, PrintingUnit.Point);  
                 mapPrinterLayer.MapExtent = shapeLayer.GetBoundingBox();  
             }  
             mapPrinterLayer.Layers.Add(shapeLayer);  
         }  
 
         private void LoadResize()  
         {  
             switch (mapPrinterLayer.ResizeMode)  
             {  
                 case PrinterResizeMode.Fixed:  
                     rbtnResizeFixed.Checked = true;  
                     break;  
                 case PrinterResizeMode.MaintainAspectRatio:  
                     rbtnResizeMaintainRaio.Checked = true;  
                     break;  
                 case PrinterResizeMode.Resizable:  
                     rbtnResize.Checked = true;  
                     break;  
                 default:  
                     break;  
             }  
         }  
 
         private void SetResize()  
         {  
             if (rbtnResize.Checked)  
             {  
                 mapPrinterLayer.ResizeMode = PrinterResizeMode.Resizable;  
             }  
             else if (rbtnResizeFixed.Checked)  
             {  
                 mapPrinterLayer.ResizeMode = PrinterResizeMode.Fixed;  
             }  
             else if (rbtnResizeMaintainRaio.Checked)  
             {  
                 mapPrinterLayer.ResizeMode = PrinterResizeMode.MaintainAspectRatio;  
             }  
         }  
 
         private void LoadDrag()  
         {  
             switch (mapPrinterLayer.DragMode)  
             {  
                 case PrinterDragMode.Fixed:  
                     rbtnDragFixed.Checked = true;  
                     break;  
                 case PrinterDragMode.Dragable:  
                     rbtnDraggable.Checked = true;  
                     break;  
                 default:  
                     break;  
             }  
         }  
 
         private void SetDrag()  
         {  
             if (rbtnDragFixed.Checked)  
             {  
                 mapPrinterLayer.DragMode = PrinterDragMode.Fixed;  
             }  
             else if (rbtnDraggable.Checked)  
             {  
                 mapPrinterLayer.DragMode = PrinterDragMode.Dragable;  
             }  
         }  
 
         private void btnBrowse_Click(object sender, EventArgs e)  
         {  
             OpenFileDialog ofd = new OpenFileDialog();  
             ofd.Filter = "Shape files (*.shp)|*.shp";  
             ofd.RestoreDirectory = true;  
 
             if (ofd.ShowDialog() == DialogResult.OK)  
             {  
                 txtPath.Text = ofd.FileName;  
             }  
         }  
     }  
 }  
 

 using System;  
 using System.Windows.Forms;  
 
 namespace PrintPreview  
 {  
     static class Program  
     {  
         /// <summary>  
         /// The main entry point for the application.  
         /// </summary>  
         [STAThread]  
         static void Main()  
         {  
             Application.EnableVisualStyles();  
             Application.SetCompatibleTextRenderingDefault(false);  
             Application.Run(new Sample());  
         }  
     }  
 }  
 

 using System;  
 using System.Collections.ObjectModel;  
 using System.Data;  
 using System.Diagnostics;  
 using System.Drawing;  
 using System.Drawing.Printing;  
 using System.Windows.Forms;  
 using PdfSharp;  
 using PdfSharp.Pdf;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.DesktopEdition;  
 
 namespace PrintPreview  
 {  
     public partial class Sample : Form  
     {  
         public Sample() { InitializeComponent(); }  
 
         #region Add PrinterLayer Elements  
 
         private void Sample_Load(object sender, EventArgs e)  
         {  
             SetupMapWithBlankPage();  
 
             AddCenteredTitleLabel();  
             AddMapLayer();  
             AddDataGridLayer();  
             AddLogoImage();  
             AddScaleLineLayer();  
             AddLegendLayer();  
             SetupComboBoxes();  
 
             winformsMap1.Refresh();  
         }  
 
         private void SetupMapWithBlankPage()  
         {  
             // Setup the map unit, you want to always use feet or meters for printer layout maps  
             winformsMap1.MapUnit = GeographyUnit.Meter;  
 
             // Here we create the default zoom levels for the sample.  We have pre-created a PrinterZoomLevelSet  
             // That pre-defines commonly used zoom levels based on percentages of zoom  
             winformsMap1.ZoomLevelSet = new PrinterZoomLevelSet(winformsMap1.MapUnit, PrinterHelper.GetPointsPerGeographyUnit(winformsMap1.MapUnit));  
 
             // Here we set the background color to gray so there is contrast with the while page  
             winformsMap1.BackgroundOverlay.BackgroundBrush = new GeoSolidBrush(GeoColor.StandardColors.LightGray);  
 
             // Create the PrinterInteractiveOverlay to contain all of the PrinterLayers.  
             // The interactive overlay allows the layers to be interacted with  
             PrinterInteractiveOverLay printerOverlay = new PrinterInteractiveOverLay();  
             winformsMap1.InteractiveOverlays.Add("PrintPreviewOverlay", printerOverlay);  
             winformsMap1.InteractiveOverlays.MoveToBottom("PrintPreviewOverlay");  
 
             // Create the PagePrinterLayer which shows the page boundary and is the area the user will  
             // arrange all of the other layer on top of.  
             PagePrinterLayer pagePrinterLayer = new PagePrinterLayer(PrinterPageSize.AnsiA, PrinterOrientation.Portrait);  
             pagePrinterLayer.Open();  
             printerOverlay.PrinterLayers.Add("PageLayer", pagePrinterLayer);  
 
             // Get the pages extent, slightly scale it up, and then set that as the default current extent  
             winformsMap1.CurrentExtent = RectangleShape.ScaleUp(pagePrinterLayer.GetPosition(), 10).GetBoundingBox();  
 
             // Set the minimum scale of the map to the last zoom level  
             winformsMap1.MinimumScale = winformsMap1.ZoomLevelSet.ZoomLevel20.Scale;  
         }  
 
         private void AddCenteredTitleLabel()  
         {  
             LabelPrinterLayer labelPrinterLayer = new LabelPrinterLayer();  
 
             //Setup the text and the font..  
             labelPrinterLayer.Text = "Population > 70 Million";  
             labelPrinterLayer.Font = new GeoFont("Arial", 10, DrawingFontStyles.Bold);  
             labelPrinterLayer.TextBrush = new GeoSolidBrush(GeoColor.StandardColors.Black);  
             labelPrinterLayer.PrinterWrapMode = PrinterWrapMode.AutoSizeText;  
 
             // Set the labels position so that is it centered on the page one inch from the top  
             RectangleShape pageBoundingbox = GetPageBoundingBox(PrintingUnit.Inch);  
             PointShape labelCenter = new PointShape();  
             labelCenter.X = pageBoundingbox.UpperRightPoint.X - pageBoundingbox.Width / 2;  
             labelCenter.Y = pageBoundingbox.UpperLeftPoint.Y - .5;  
 
             labelPrinterLayer.SetPosition(5, 1, labelCenter, PrintingUnit.Inch);  
 
             // Find the PrinterInteractiveOverlay so we can add the new LabelPrinterLayer  
             PrinterInteractiveOverLay printerInteractiveOverLay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
             printerInteractiveOverLay.PrinterLayers.Add("LabelLayer", labelPrinterLayer);  
         }  
 
         private void AddMapLayer()  
         {  
             // Create the MapPrinterLayer and set the position  
             MapPrinterLayer mapPrinterLayer = new MapPrinterLayer();  
             mapPrinterLayer.MapUnit = GeographyUnit.DecimalDegree;  
             mapPrinterLayer.BackgroundMask = new AreaStyle(new GeoPen(GeoColor.StandardColors.Black, 1));  
             mapPrinterLayer.Open();  
 
             // Set the maps position slightly below the pages center and 8 inches wide and 7 inches tall  
             RectangleShape pageBoundingbox = GetPageBoundingBox(PrintingUnit.Inch);  
             mapPrinterLayer.SetPosition(8, 7, pageBoundingbox.GetCenterPoint().X, pageBoundingbox.GetCenterPoint().Y + 1, PrintingUnit.Inch);  
 
             // Setup the intial extent and ensure they snap to the default ZoomLevel  
             ZoomLevelSet zoomLevelSet = new ZoomLevelSet();  
             mapPrinterLayer.MapExtent = ExtentHelper.ZoomToScale(zoomLevelSet.ZoomLevel03.Scale, new RectangleShape(-180, 90, 180, -90), mapPrinterLayer.MapUnit, (float)mapPrinterLayer.GetBoundingBox().Width, (float)mapPrinterLayer.GetBoundingBox().Height);  
 
             // Add the World Map Kit layer as the background  
             WorldMapKitLayer worldMapKitLayer = new WorldMapKitLayer();  
             worldMapKitLayer.Projection = WorldMapKitProjection.DecimalDegrees;  
             mapPrinterLayer.Layers.Add(worldMapKitLayer);  
 
             // Setup the Countries mapping layer  
             ShapeFileFeatureLayer shapefileFeatureLayer = new ShapeFileFeatureLayer(@"data/Countries02.shp", ShapeFileReadWriteMode.ReadOnly);  
             shapefileFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
 
             //Create the class break style for countries less than 70 million  
             ClassBreakStyle classBreakStyle = new ClassBreakStyle("POP_CNTRY");  
 
             // Create the style and class break for countries with greater and 70 million  
             AreaStyle hatchAreaStyle = new AreaStyle(new GeoSolidBrush(GeoColor.FromArgb(100, GeoColor.StandardColors.Green)));  
             classBreakStyle.ClassBreaks.Add(new ClassBreak(70000000, hatchAreaStyle));  
 
             // Add the class break style to the layer  
             shapefileFeatureLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(classBreakStyle);  
 
             // Add the new country layer to the MapPrinterLayer  
             mapPrinterLayer.Layers.Add(shapefileFeatureLayer);  
 
             // Add the MapPrinterLayer to the PrinterInteractiveOverlay  
             PrinterInteractiveOverLay printerInteractiveOverLay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
             printerInteractiveOverLay.PrinterLayers.Add("MapLayer", mapPrinterLayer);  
         }  
 
         private void AddLegendLayer()  
         {  
             LegendItem title = new LegendItem();  
             title.TextStyle = new TextStyle("Map Legend", new GeoFont("Arial", 10, DrawingFontStyles.Bold), new GeoSolidBrush(GeoColor.SimpleColors.Black));  
 
             LegendItem legendItem1 = new LegendItem();  
             legendItem1.ImageStyle = new AreaStyle(new GeoSolidBrush(GeoColor.FromArgb(170, GeoColor.StandardColors.Green)));  
             legendItem1.TextStyle = new TextStyle("Population > 70 million", new GeoFont("Arial", 8), new GeoSolidBrush(GeoColor.SimpleColors.Black));  
 
             LegendItem legendItem2 = new LegendItem();  
             legendItem2.ImageStyle = AreaStyles.Country1;  
             legendItem2.TextStyle = new TextStyle("Population < 70 million", new GeoFont("Arial", 8), new GeoSolidBrush(GeoColor.SimpleColors.Black));  
 
             LegendPrinterLayer legendPrinterLayer = new LegendPrinterLayer();  
             legendPrinterLayer.Title = title;  
             legendPrinterLayer.LegendItems.Add(legendItem1);  
             legendPrinterLayer.LegendItems.Add(legendItem2);  
             legendPrinterLayer.Width = 160;  
             legendPrinterLayer.Height = 100;  
             legendPrinterLayer.SetPosition(2, 1, -2.9, 3.9, PrintingUnit.Inch);  
 
             PrinterInteractiveOverLay printerInteractiveOverLay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
             printerInteractiveOverLay.PrinterLayers.Add("LegendPrinterLayer", legendPrinterLayer);  
         }  
 
         private void AddDataGridLayer()  
         {  
             // Create the DataGridPrinterLayer  
             DataGridPrinterLayer dataGridPrinterLayer = new DataGridPrinterLayer();  
             dataGridPrinterLayer.TextFont = new GeoFont("Arial", 8);  
             dataGridPrinterLayer.TextHorizontalAlignment = TextHorizontalAlignment.Left;  
 
             // Set the data grid position 4 inches below the page center and 8 inches wide and 2.5 inches tall  
             RectangleShape pageBoundingbox = GetPageBoundingBox(PrintingUnit.Inch);  
             dataGridPrinterLayer.SetPosition(8, 2.5, pageBoundingbox.GetCenterPoint().X, pageBoundingbox.GetCenterPoint().Y - 4, PrintingUnit.Inch);  
 
             //Create the data table and columns  
             dataGridPrinterLayer.DataTable = new DataTable();  
             dataGridPrinterLayer.DataTable.Columns.Add("Country");  
             dataGridPrinterLayer.DataTable.Columns.Add("Population");  
             dataGridPrinterLayer.DataTable.Columns.Add("CurrencyCode");  
             dataGridPrinterLayer.DataTable.Columns.Add("Area");  
 
             // Find all of the countries with a population greater than 70 million  
             // and add those items to the data table  
             ShapeFileFeatureLayer shapefileFeatureLayer = new ShapeFileFeatureLayer(@"data/Countries02.shp", ShapeFileReadWriteMode.ReadOnly);  
             shapefileFeatureLayer.Open();  
             Collection<Feature> features = shapefileFeatureLayer.QueryTools.GetAllFeatures(ReturningColumnsType.AllColumns);  
             shapefileFeatureLayer.Close();  
 
             foreach (Feature feature in features)  
             {  
                 double pop = Convert.ToDouble(feature.ColumnValues["Pop_cntry"].ToString());  
                 if (pop > 70000000)  
                 {  
                     dataGridPrinterLayer.DataTable.Rows.Add(new object[4] { feature.ColumnValues["Cntry_Name"], feature.ColumnValues["Pop_cntry"], feature.ColumnValues["curr_code"], feature.ColumnValues["sqkm"] });  
                 }  
             }  
 
             // Add the DataGridPrinterLayer to the PrinterInteractiveOverlay  
             PrinterInteractiveOverLay printerInteractiveOverLay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
             printerInteractiveOverLay.PrinterLayers.Add("DataGridLayer", dataGridPrinterLayer);  
         }  
 
         private void AddLogoImage()  
         {  
             //Load the image to a GeoImage and then create the ImagePrinterLayer using that image  
             GeoImage compassGeoImage = new GeoImage(@"Images\Compass.png");  
             ImagePrinterLayer imagePrinterLayer = new ImagePrinterLayer(compassGeoImage);  
 
             // Set the imagePrinterLayer position offset from the page center and .75 inches wide and .75 inches tall  
             RectangleShape pageBoundingbox = GetPageBoundingBox(PrintingUnit.Inch);  
             imagePrinterLayer.SetPosition(.75, .75, pageBoundingbox.GetCenterPoint().X + 3.5, pageBoundingbox.GetCenterPoint().Y - 2.0, PrintingUnit.Inch);  
 
             // Add the imagePrinterLayer to the PrinterInteractiveOverlay  
             PrinterInteractiveOverLay printerInteractiveOverLay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
             printerInteractiveOverLay.PrinterLayers.Add("ImageLayer", imagePrinterLayer);  
         }  
 
         private void AddScaleLineLayer()  
         {  
             // Get the PrinterInteractiveOverlay  
             PrinterInteractiveOverLay printerInteractiveOverLay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
 
             // Grab the MapPrinterLayer as we need to pass that into the scaleLinePrinterLayer so it  
             // can be synced up to the map itself in real-time  
             MapPrinterLayer mapPrinterLayer = (MapPrinterLayer)printerInteractiveOverLay.PrinterLayers["MapLayer"];  
 
             //Create the scaleLinePrinterLayer and pass in the MapPrinterLayer  
             ScaleLinePrinterLayer scaleLinePrinterLayer = new ScaleLinePrinterLayer(mapPrinterLayer);  
             scaleLinePrinterLayer.MapUnit = GeographyUnit.DecimalDegree;  
 
             // Set the scale line position offset from the page center and 1.25 inches wide and .25 inches tall  
             RectangleShape pageBoundingbox = GetPageBoundingBox(PrintingUnit.Inch);  
             scaleLinePrinterLayer.SetPosition(1.25, .25, pageBoundingbox.GetCenterPoint().X - 3.25, pageBoundingbox.GetCenterPoint().Y - 2.25, PrintingUnit.Inch);  
 
             // Add the ScaleLinePrinterLayer to the PrinterInteractiveOverlay  
             printerInteractiveOverLay.PrinterLayers.Add("ScaleLineLayer", scaleLinePrinterLayer);  
         }  
 
         #endregion  
 
         #region Export Buttons  
 
         private void btnPrintPreview_Click(object sender, EventArgs e)  
         {  
             PrinterInteractiveOverLay printerInteractiveOverLay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
             PagePrinterLayer pagePrinterLayer = printerInteractiveOverLay.PrinterLayers["PageLayer"] as PagePrinterLayer;  
 
             PrintDialog printDialog = new PrintDialog();  
             PrintDocument printDocument = new PrintDocument();  
             printDocument.DefaultPageSettings.Landscape = true;  
             if (pagePrinterLayer.Orientation == PrinterOrientation.Portrait)  
             {  
                 printDocument.DefaultPageSettings.Landscape = false;  
             }  
 
             printDocument.DefaultPageSettings.PaperSize = GetPrintPreviewPaperSize(pagePrinterLayer);  
 
             PrinterGeoCanvas printerGeoCanvas = new PrinterGeoCanvas();  
             printerGeoCanvas.DrawingArea = printDocument.DefaultPageSettings.Bounds;  
             printerGeoCanvas.BeginDrawing(printDocument, pagePrinterLayer.GetBoundingBox(), winformsMap1.MapUnit);  
 
             // Loop through all of the PrintingLayer in the PrinterInteractiveOverlay and print all of the  
             // except for the PagePrinterLayer  
             Collection<SimpleCandidate> labelsInAllLayers = new Collection<SimpleCandidate>();  
             foreach (PrinterLayer printerLayer in printerInteractiveOverLay.PrinterLayers)  
             {  
                 printerLayer.IsDrawing = true;  
                 if (!(printerLayer is PagePrinterLayer))  
                 {  
                     printerLayer.Draw(printerGeoCanvas, labelsInAllLayers);  
                 }  
                 printerLayer.IsDrawing = false;  
             }  
 
             printerGeoCanvas.Flush();  
 
             PrintPreviewDialog printPreviewDialog = new PrintPreviewDialog();  
             printPreviewDialog.Document = printDocument;  
             DialogResult dialogResult = printPreviewDialog.ShowDialog();  
         }  
 
         private void btnExportBitmap_Click(object sender, EventArgs e)  
         {  
             PrinterInteractiveOverLay printerInteractiveOverLay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
             PagePrinterLayer pagePrinterLayer = printerInteractiveOverLay.PrinterLayers["PageLayer"] as PagePrinterLayer;  
 
             // Create a bitmap that is the size of the pages bounding box.  The page by default is in points unit  
             // system which is very similar to pixels so that ampping is nice.  
             Bitmap bitmap = null;  
             try  
             {  
                 bitmap = new Bitmap((int)pagePrinterLayer.GetBoundingBox().Width, (int)pagePrinterLayer.GetBoundingBox().Height);  
 
                 // Create a GdiPlusGeoCanvas and start the drawing  
                 GdiPlusGeoCanvas gdiPlusGeoCanvas = new GdiPlusGeoCanvas();  
                 gdiPlusGeoCanvas.BeginDrawing(bitmap, pagePrinterLayer.GetBoundingBox(), winformsMap1.MapUnit);  
 
                 // Loop through all of the PrintingLayer in the PrinterInteractiveOverlay and print all of the  
                 // except for the PagePrinterLayer  
                 Collection<SimpleCandidate> labelsInAllLayers = new Collection<SimpleCandidate>();  
                 foreach (PrinterLayer printerLayer in printerInteractiveOverLay.PrinterLayers)  
                 {  
                     printerLayer.IsDrawing = true;  
                     if (!(printerLayer is PagePrinterLayer))  
                     {  
                         printerLayer.Draw(gdiPlusGeoCanvas, labelsInAllLayers);  
                     }  
                     printerLayer.IsDrawing = false;  
                 }  
 
                 // End the drawing  
                 gdiPlusGeoCanvas.EndDrawing();  
 
                 //Save the resulting bitmap to a file and open the file to show the user  
                 string filename = "PrintingResults.bmp";  
                 bitmap.Save(filename);  
                 Process.Start(filename);  
             }  
             catch (Exception ex)  
             {  
                 MessageBox.Show(ex.Message + " " + ex.StackTrace, "Exception");  
             }  
             finally  
             {  
                 if (bitmap != null) { bitmap.Dispose(); }  
             }  
         }  
 
         private void btnExportToPdf_Click(object sender, EventArgs e)  
         {  
             // Get the PrinterInteractiveOverlay and PagePrinterLayer as we are going to need them below  
             PrinterInteractiveOverLay printerInteractiveOverLay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
             PagePrinterLayer pagePrinterLayer = printerInteractiveOverLay.PrinterLayers["PageLayer"] as PagePrinterLayer;  
 
             PdfDocument pdfDocument = null;  
             PdfPage pdfPage = null;  
 
             try  
             {  
                 // Create the PDF documents, pages, and copnfigure them  
                 pdfDocument = new PdfDocument();  
                 pdfPage = pdfDocument.AddPage();  
                 pdfPage.Orientation = pagePrinterLayer.Orientation == PrinterOrientation.Portrait ? PageOrientation.Portrait : PageOrientation.Landscape;  
                 pdfPage.Size = GetPdfPageSize(pagePrinterLayer.PageSize);  
 
                 // Create the PdfGeoCanvas and pass tha PdfPage into the BeginDrawing  
                 PdfGeoCanvas pdfGeoCanvas = new PdfGeoCanvas();  
                 pdfGeoCanvas.BeginDrawing(pdfPage, pagePrinterLayer.GetBoundingBox(), winformsMap1.MapUnit);  
 
                 // Loop through all of the PrinterLayers and draw them to the canvas except for the  
                 // PagePrinterLayer which is just used for the visual layout  
                 Collection<SimpleCandidate> labelsInAllLayers = new Collection<SimpleCandidate>();  
                 foreach (PrinterLayer printerLayer in printerInteractiveOverLay.PrinterLayers)  
                 {  
                     printerLayer.IsDrawing = true;  
                     if (!(printerLayer is PagePrinterLayer))  
                     {  
                         printerLayer.Draw(pdfGeoCanvas, labelsInAllLayers);  
                     }  
                     printerLayer.IsDrawing = false;  
                 }  
 
                 // Finish up the drawing  
                 pdfGeoCanvas.EndDrawing();  
 
                 // Dave the PDF document and launch it in the default viewer to show the user  
                 string filename = "PrintingResults.pdf";  
                 pdfDocument.Save(filename);  
                 Process.Start(filename);  
             }  
             catch (Exception ex)  
             {  
                 MessageBox.Show(ex.Message + " " + ex.StackTrace, "Exception");  
             }  
             finally  
             {  
                 if (pdfDocument != null) { pdfDocument.Dispose(); }  
             }  
         }  
 
         private void btnPrint_Click(object sender, EventArgs e)  
         {  
             PrinterInteractiveOverLay printerInteractiveOverLay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
             PagePrinterLayer pagePrinterLayer = printerInteractiveOverLay.PrinterLayers["PageLayer"] as PagePrinterLayer;  
 
             PrintDocument printDocument = new PrintDocument();  
             printDocument.DefaultPageSettings.Landscape = true;  
             if (pagePrinterLayer.Orientation == PrinterOrientation.Portrait)  
             {  
                 printDocument.DefaultPageSettings.Landscape = false;  
             }  
 
             printDocument.DefaultPageSettings.PaperSize = GetPrintPreviewPaperSize(pagePrinterLayer);  
 
             PrinterGeoCanvas printerGeoCanvas = new PrinterGeoCanvas();  
             printerGeoCanvas.DrawingArea = new Rectangle(0, 0, Convert.ToInt32(printDocument.DefaultPageSettings.PrintableArea.Width), Convert.ToInt32(printDocument.DefaultPageSettings.PrintableArea.Height));  
             printerGeoCanvas.BeginDrawing(printDocument, pagePrinterLayer.GetBoundingBox(), winformsMap1.MapUnit);  
 
             // Loop through all of the PrintingLayer in the PrinterInteractiveOverlay and print all of the  
             // except for the PagePrinterLayer  
             Collection<SimpleCandidate> labelsInAllLayers = new Collection<SimpleCandidate>();  
             foreach (PrinterLayer printerLayer in printerInteractiveOverLay.PrinterLayers)  
             {  
                 printerLayer.IsDrawing = true;  
                 if (!(printerLayer is PagePrinterLayer))  
                 {  
                     printerLayer.Draw(printerGeoCanvas, labelsInAllLayers);  
                 }  
                 printerLayer.IsDrawing = false;  
             }  
 
             printerGeoCanvas.EndDrawing();  
         }  
         #endregion  
 
         #region Map Events  
         void winformsMap1_CurrentScaleChanged(object sender, CurrentScaleChangedWinformsMapEventArgs e)  
         {  
             // Here we sync up the zoom combox to the map's zoom level.  
             PrinterZoomLevelSet printerZoomLevelSet = (PrinterZoomLevelSet)winformsMap1.ZoomLevelSet;  
             ZoomLevel currentZoomLevel = printerZoomLevelSet.GetZoomLevel(winformsMap1.CurrentExtent, winformsMap1.Width, winformsMap1.MapUnit);  
             cboZoom.SelectedItem = printerZoomLevelSet.GetZoomPercentage(currentZoomLevel) + "%";  
         }  
 
         private void winformsMap1_MapClick(object sender, MapClickWinformsMapEventArgs e)  
         {  
             // Here we loop through all of the PrinterLayers to find the one the user right mouse clicked on.  
             // Then we show the right click menu to give the user some options  
             if (e.MouseButton == MapMouseButton.Right)  
             {  
                 PrinterInteractiveOverLay printerOverlay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
                 for (int i = printerOverlay.PrinterLayers.Count - 1; i >= 0; i--)  
                 {  
                     if (printerOverlay.PrinterLayers[i].GetType() != typeof(PagePrinterLayer))  
                     {  
                         RectangleShape boundingBox = printerOverlay.PrinterLayers[i].GetPosition();  
                         if (boundingBox.Contains(e.WorldLocation))  
                         {  
                             cmRightClick.Tag = printerOverlay.PrinterLayers[i];  
                             cmRightClick.Show(winformsMap1, new Point((int)(e.ScreenX), (int)(e.ScreenY)));  
                             break;  
                         }  
                     }  
                 }  
             }  
         }  
         #endregion  
 
         #region Pan & Zoom Buttons  
 
         private void btnZoomIn_Click(object sender, EventArgs e)  
         {  
             // Grab the MapPrinterLayer and adjust the extent  
             PrinterInteractiveOverLay printerOverlay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
             MapPrinterLayer mapPrinterLayer = ((MapPrinterLayer)(printerOverlay.PrinterLayers["MapLayer"]));  
 
             // Here we snap the current scale to the default zoomLevelSet when we zoom in  
             ZoomLevelSet zoomLevelSet = new ZoomLevelSet();  
             double newScale = ZoomLevelSet.GetLowerZoomLevelScale(ExtentHelper.GetScale(mapPrinterLayer.MapExtent, (float)mapPrinterLayer.GetBoundingBox().Width, mapPrinterLayer.MapUnit), zoomLevelSet);  
             mapPrinterLayer.MapExtent = ExtentHelper.ZoomToScale(newScale, mapPrinterLayer.MapExtent, mapPrinterLayer.MapUnit, (float)mapPrinterLayer.GetBoundingBox().Width, (float)mapPrinterLayer.GetBoundingBox().Height);  
 
             winformsMap1.Refresh();  
         }  
 
         private void btnZoomOut_Click(object sender, EventArgs e)  
         {  
             // Grab the MapPrinterLayer and adjust the extent  
             PrinterInteractiveOverLay printerOverlay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
             MapPrinterLayer mapPrinterLayer = ((MapPrinterLayer)(printerOverlay.PrinterLayers["MapLayer"]));  
 
             // Here we snap the current scale to the default zoomLevelSet when we zoom out  
             ZoomLevelSet zoomLevelSet = new ZoomLevelSet();  
             double newScale = ZoomLevelSet.GetHigherZoomLevelScale(ExtentHelper.GetScale(mapPrinterLayer.MapExtent, (float)mapPrinterLayer.GetBoundingBox().Width, mapPrinterLayer.MapUnit), zoomLevelSet);  
             mapPrinterLayer.MapExtent = ExtentHelper.ZoomToScale(newScale, mapPrinterLayer.MapExtent, mapPrinterLayer.MapUnit, (float)mapPrinterLayer.GetBoundingBox().Width, (float)mapPrinterLayer.GetBoundingBox().Height);  
 
             winformsMap1.Refresh();  
         }  
 
         private void btnPan_Click(object sender, EventArgs e)  
         {  
             // Grab the MapPrinterLayer and adjust the extent  
             PrinterInteractiveOverLay printerOverlay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
 
             MapPrinterLayer mapPrinterLayer = ((MapPrinterLayer)(printerOverlay.PrinterLayers["MapLayer"]));  
 
             if (sender == btnPanUp)  
             { mapPrinterLayer.MapExtent = ExtentHelper.Pan(mapPrinterLayer.MapExtent, PanDirection.Up, 30); }  
             else if (sender == btnPanDown)  
             { mapPrinterLayer.MapExtent = ExtentHelper.Pan(mapPrinterLayer.MapExtent, PanDirection.Down, 30); }  
             else if (sender == btnPanLeft)  
             { mapPrinterLayer.MapExtent = ExtentHelper.Pan(mapPrinterLayer.MapExtent, PanDirection.Left, 30); }  
             else if (sender == btnPanRight)  
             { mapPrinterLayer.MapExtent = ExtentHelper.Pan(mapPrinterLayer.MapExtent, PanDirection.Right, 30); }  
 
             winformsMap1.Refresh();  
         }  
 
         #endregion  
 
         #region Combo Boxes  
 
         private void SetupComboBoxes()  
         {  
             // Set the default combobox items  
             cboPageSize.SelectedIndex = 0;  
             cboOrientation.SelectedIndex = 0;  
 
             //Setup the zoom level combobox to relfect the zoom percentages  
             foreach (ZoomLevel level in winformsMap1.ZoomLevelSet.GetZoomLevels())  
             {  
                 cboZoom.Items.Add(((PrinterZoomLevelSet)winformsMap1.ZoomLevelSet).GetZoomPercentage(level) + "%");  
             }  
         }  
 
         private void cboPageSize_SelectedIndexChanged(object sender, EventArgs e)  
         {  
             // When the page size combobox is changed then we update the PagePrinterLayer to reflect the changes  
             if (((ComboBox)sender).Focused)  
             {  
                 PrinterInteractiveOverLay printerInteractiveOverLay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
                 PagePrinterLayer pagePrinterLayer = (PagePrinterLayer)printerInteractiveOverLay.PrinterLayers["PageLayer"];  
 
                 string selectText = cboPageSize.SelectedItem.ToString();  
                 if (selectText.StartsWith("ANSI A"))  
                     pagePrinterLayer.PageSize = PrinterPageSize.AnsiA;  
                 else if (selectText.StartsWith("ANSI B"))  
                     pagePrinterLayer.PageSize = PrinterPageSize.AnsiB;  
                 else if (selectText.StartsWith("ANSI C"))  
                     pagePrinterLayer.PageSize = PrinterPageSize.AnsiC;  
                 else if (selectText.StartsWith("ANSI D"))  
                     pagePrinterLayer.PageSize = PrinterPageSize.AnsiD;  
                 else if (selectText.StartsWith("ANSI E"))  
                     pagePrinterLayer.PageSize = PrinterPageSize.AnsiE;  
 
                 winformsMap1.Refresh();  
             }  
         }  
 
         private void cboOrientation_SelectedIndexChanged(object sender, EventArgs e)  
         {  
             // When the orientation combobox is changed then we update the PagePrinterLayer to reflect the changes  
             if (((ComboBox)sender).Focused)  
             {  
                 PrinterInteractiveOverLay printerInteractiveOverLay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
                 PagePrinterLayer pagePrinterLayer = (PagePrinterLayer)printerInteractiveOverLay.PrinterLayers["PageLayer"];  
 
                 string selectText = cboOrientation.SelectedItem.ToString();  
                 if (selectText.ToUpper() == "LANDSCAPE")  
                 {  
                     pagePrinterLayer.Orientation = PrinterOrientation.Landscape;  
                 }  
                 else if (selectText.ToUpper() == "PORTRAIT")  
                 {  
                     pagePrinterLayer.Orientation = PrinterOrientation.Portrait;  
                 }  
 
                 winformsMap1.Refresh();  
             }  
         }  
 
         private void cboZoom_SelectionChangeCommitted(object sender, EventArgs e)  
         {  
             if (((ComboBox)sender).Focused)  
             {  
                 String zoomString = (String)cboZoom.SelectedItem;  
                 double currentZoom = Double.Parse(zoomString.Replace("%", ""));  
                 winformsMap1.CurrentScale = PrinterHelper.GetPointsPerGeographyUnit(winformsMap1.MapUnit) / (currentZoom / 100);  
                 winformsMap1.Refresh();  
             }  
         }  
 
         #endregion  
 
         #region Toolbox  
         private void toolStrip1_ItemClicked(object sender, ToolStripItemClickedEventArgs e)  
         {  
             PrinterInteractiveOverLay printerInteractiveOverLay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
             PrinterLayer printerLayer = null;  
 
             string name = e.ClickedItem.Text.ToLower();  
             switch (name)  
             {  
                 case "label":  
                     printerLayer = new LabelPrinterLayer();  
                     printerLayer.SetPosition(2, 1, 0, 0, PrintingUnit.Inch);  
                     break;  
                 case "image":  
                     printerLayer = new ImagePrinterLayer();  
                     break;  
                 case "scale line":  
                     MessageBox.Show("NotImplemented");  
                     break;  
                 case "scale bar":  
                     MessageBox.Show("NotImplemented");  
                     break;  
                 case "data grid":  
                     printerLayer = new DataGridPrinterLayer();  
                     printerLayer.SetPosition(1, 1, 0, 0, PrintingUnit.Inch);  
                     break;  
                 default:  
                     break;  
             }  
 
             if (printerLayer != null && ShowPrinterLayerProperties(printerLayer) == DialogResult.OK)  
             {  
                 printerInteractiveOverLay.PrinterLayers.Add(printerLayer);  
                 winformsMap1.Refresh();  
             }  
         }  
         #endregion  
 
         #region Right Click and Dialogs  
         private void cmRightClick_Click(object sender, EventArgs e)  
         {  
             PrinterInteractiveOverLay printerInteractiveOverLay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
             PrinterLayer printerLayer = (PrinterLayer)cmRightClick.Tag;  
 
             ToolStripItem selectedItem = cmRightClick.GetItemAt(((MouseEventArgs)e).X, ((MouseEventArgs)e).Y);  
             if (selectedItem.Name == "tsmRemove")  
             {  
                 printerInteractiveOverLay.PrinterLayers.Remove(printerLayer);  
             }  
             else if (selectedItem.Name == "tsmProperty")  
             {  
                 ShowPrinterLayerProperties(printerLayer);  
             }  
             winformsMap1.Refresh();  
         }  
 
         private DialogResult ShowPrinterLayerProperties(PrinterLayer printerLayer)  
         {  
             DialogResult dialogResult = DialogResult.Cancel;  
 
             if (printerLayer.GetType() == typeof(LabelPrinterLayer))  
             {  
                 LabelPrinterLayerProperty dialog = new LabelPrinterLayerProperty((LabelPrinterLayer)printerLayer);  
                 dialog.StartPosition = FormStartPosition.CenterParent;  
                 dialogResult = dialog.ShowDialog();  
             }  
             else if (printerLayer.GetType() == typeof(ScaleBarPrinterLayer))  
             {  
                 MessageBox.Show("Scalebar (Coming Soon)");  
             }  
             else if (printerLayer.GetType() == typeof(ScaleLinePrinterLayer))  
             {  
                 MessageBox.Show("Scaleline (Coming Soon)");  
             }  
             else if (printerLayer.GetType() == typeof(ImagePrinterLayer))  
             {  
                 ImagePrinterLayerProperty dialog = new ImagePrinterLayerProperty((ImagePrinterLayer)printerLayer);  
                 dialog.StartPosition = FormStartPosition.CenterParent;  
                 dialogResult = dialog.ShowDialog();  
             }  
             else if (printerLayer.GetType() == typeof(DataGridPrinterLayer))  
             {  
                 DataGridPrinterLayerProperty dialog = new DataGridPrinterLayerProperty((DataGridPrinterLayer)printerLayer);  
                 dialog.StartPosition = FormStartPosition.CenterParent;  
                 dialogResult = dialog.ShowDialog();  
             }  
 
             return dialogResult;  
         }  
         #endregion  
 
         #region Helper Methods  
 
         private RectangleShape GetPageBoundingBox(PrintingUnit unit)  
         {  
             // This helper method gets the pages bounding box in the unit requested  
             PrinterInteractiveOverLay printerInteractiveOverLay = (PrinterInteractiveOverLay)winformsMap1.InteractiveOverlays["PrintPreviewOverlay"];  
             PagePrinterLayer pagePrinterLayer = (PagePrinterLayer)printerInteractiveOverLay.PrinterLayers["PageLayer"];  
             return pagePrinterLayer.GetPosition(unit); ;  
         }  
 
         private PageSize GetPdfPageSize(PrinterPageSize pageSize)  
         {  
             PageSize pdfPageSize = PageSize.Letter;  
             switch (pageSize)  
             {  
                 case PrinterPageSize.AnsiA:  
                     pdfPageSize = PageSize.Letter;  
                     break;  
                 case PrinterPageSize.AnsiB:  
                     pdfPageSize = PageSize.Ledger;  
                     break;  
                 case PrinterPageSize.AnsiC:  
                     pdfPageSize = PageSize.A2;  
                     break;  
                 case PrinterPageSize.AnsiD:  
                     pdfPageSize = PageSize.A1;  
                     break;  
                 case PrinterPageSize.AnsiE:  
                     pdfPageSize = PageSize.A0;  
                     break;  
                 case PrinterPageSize.Custom:  
                     throw new NotSupportedException();  
                 default:  
                     throw new NotSupportedException();  
             }  
             return pdfPageSize;  
         }  
 
         private PaperSize GetPrintPreviewPaperSize(PagePrinterLayer pagePrinterLayer)  
         {  
             PaperSize printPreviewPaperSize = new PaperSize("AnsiA", 850, 1100);  
             switch (pagePrinterLayer.PageSize)  
             {  
                 case PrinterPageSize.AnsiA:  
                     printPreviewPaperSize = new PaperSize("AnsiA", 850, 1100);  
                     break;  
                 case PrinterPageSize.AnsiB:  
                     printPreviewPaperSize = new PaperSize("AnsiB", 1100, 1700);  
                     break;  
                 case PrinterPageSize.AnsiC:  
                     printPreviewPaperSize = new PaperSize("AnsiC", 1700, 2200);  
                     break;  
                 case PrinterPageSize.AnsiD:  
                     printPreviewPaperSize = new PaperSize("AnsiD", 2200, 3400);  
                     break;  
                 case PrinterPageSize.AnsiE:  
                     printPreviewPaperSize = new PaperSize("AnsiE", 3400, 4400);  
                     break;  
                 case PrinterPageSize.Custom:  
                     printPreviewPaperSize = new PaperSize("Custom Size", (int)pagePrinterLayer.CustomWidth, (int)pagePrinterLayer.CustomHeight);  
                     break;  
                 default:  
                     break;  
             }  
 
             return printPreviewPaperSize;  
         }  
 
         #endregion  
     }  
 }

 using System;  
 using System.Collections.Generic;  
 using System.ComponentModel;  
 using System.Data;  
 using System.Drawing;  
 using System.Text;  
 using System.Windows.Forms;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.DesktopEdition;  
 using System.IO;  
 using System.Collections.ObjectModel;  
 
 namespace PrintPreview  
 {  
     public partial class ScalePrinterLayerProperty : Form  
     {  
         PrinterLayer layer = null;  
         PrinterInteractiveOverLay overlay = null;  
         GeoCollection<MapPrinterLayer> mapLayers = new GeoCollection<MapPrinterLayer>();  
 
         public ScalePrinterLayerProperty(PrinterLayer layer, PrinterInteractiveOverLay overlay)  
         {  
             InitializeComponent();  
 
             this.layer = layer;  
             this.overlay = overlay;  
         }  
 
 
         private void Window_Load(object sender, EventArgs e)  
         {  
             LoadLayerProperties();  
             LoadResize();  
             LoadDrag();  
         }  
 
         private void btnOK_Click(object sender, EventArgs e)  
         {  
             SetLayerProperties();  
             SetResize();  
             SetDrag();  
             Close();  
 
             DialogResult = DialogResult.OK;  
         }  
 
         private void LoadLayerProperties()  
         {  
             //foreach (PrinterLayer printerLayer in overlay .PrinterLayers)  
             //{  
             //    if (printerLayer .GetType () == typeof (MapPrinterLayer))  
             //    {  
             //        string fileName = ((ShapeFileFeatureLayer)((MapPrinterLayer)printerLayer).Layers[0]).ShapePathFileName;  
             //        fileName = Path.GetFileNameWithoutExtension(fileName);  
             //        cbxMap.Items.Add(fileName);  
             //        mapLayers.Add(((MapPrinterLayer)printerLayer ).GetHashCode (), (MapPrinterLayer)printerLayer);  
             //    }  
            // }  
         }  
 
         private void SetLayerProperties()  
         {  
             //GeoImage image = new GeoImage(txtPath.Text);  
             //layer.NeedleImage = image;  
 
             //layer.Open();  
             //PointShape centerPoint = layer.GetPosition().GetCenterPoint();  
             //layer.SetPosition(image.GetWidth(), image.GetHeight(), centerPoint, PrintingUnit.Point);  
         }  
 
         private void LoadResize()  
         {  
             switch (layer.ResizeMode)  
             {  
                 case PrinterResizeMode.Fixed:  
                     rbtnResizeFixed.Checked = true;  
                     break;  
                 case PrinterResizeMode.MaintainAspectRatio:  
                     rbtnResizeMaintainRaio.Checked = true;  
                     break;  
                 case PrinterResizeMode.Resizable:  
                     rbtnResize.Checked = true;  
                     break;  
                 default:  
                     break;  
             }  
         }  
 
         private void SetResize()  
         {  
             if (rbtnResize.Checked)  
             {  
                 layer.ResizeMode = PrinterResizeMode.Resizable;  
             }  
             else if (rbtnResizeFixed.Checked)  
             {  
                 layer.ResizeMode = PrinterResizeMode.Fixed;  
             }  
             else if (rbtnResizeMaintainRaio.Checked)  
             {  
                 layer.ResizeMode = PrinterResizeMode.MaintainAspectRatio;  
             }  
         }  
 
         private void LoadDrag()  
         {  
             switch (layer.DragMode)  
             {  
                 case PrinterDragMode.Fixed:  
                     rbtnDragFixed.Checked = true;  
                     break;  
                 case PrinterDragMode.Dragable:  
                     rbtnDraggable.Checked = true;  
                     break;  
                 default:  
                     break;  
             }  
         }  
 
         private void SetDrag()  
         {  
             if (rbtnDragFixed.Checked)  
             {  
                 layer.DragMode = PrinterDragMode.Fixed;  
             }  
             else if (rbtnDraggable.Checked)  
             {  
                 layer.DragMode = PrinterDragMode.Dragable;  
             }  
         }  
 
 
         private void btnBrowse_Click(object sender, EventArgs e)  
         {  
             //OpenFileDialog ofd = new OpenFileDialog();  
             //ofd.Filter = "All files (*.*)|*.*";  
             //ofd.RestoreDirectory = true;  
 
             //if (ofd.ShowDialog() == DialogResult.OK)  
             //{  
             //    txtPath.Text = ofd.FileName;  
             //}  
         }  
     }  
 }