devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

opencascade c#例程解析

作者：2023面试高手 | 2024-02-28 21:24:07

赞

踩

opencascade c#例程解析

1.编译

将msvc.bat文件拖入vs2022的x64 native tools，即可

2.about.xaml

  1. <Window
  2. 	xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  3. 	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  4. 	x:Class="IE_WPF_WinForms.AboutDialog"
  5. 	x:Name="Window"
  6. 	xmlns:local="clr-namespace:IE_WPF_WinForms"
  7. 	Title="About Import/Export Sample"
  8. 	Width="312" Height="285">
  9. 	
  10. 	<StackPanel Orientation="Vertical">
  11. 		<Label Content="Import/Export Sample," HorizontalAlignment="Center"/>
  12. 		<Label Content="Open CASCADE Technology " HorizontalAlignment="Center"/>
  13.         <Image Source="res\occ_logo.bmp" Width="194" Height="100" />
  14. 		<Label Content="Copyright (C) 2004-2013, Open CASCADE S.A.S" HorizontalAlignment="Center"/>
  15. 		<Label Content="http://www.opencascade.com" HorizontalAlignment="Center" FontFamily="Modern No. 20"/>
  16. 		<Button Content="OK" HorizontalAlignment="Center" Width="75" Command="local:IECommands.AboutOk"/>
  17. 	</StackPanel>	
  18. </Window>
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Windows;
  5. using System.Windows.Controls;
  6. using System.Windows.Data;
  7. using System.Windows.Documents;
  8. using System.Windows.Input;
  9. using System.Windows.Media;
  10. using System.Windows.Media.Imaging;
  11. using System.Windows.Shapes;
  12.  
  13. namespace IE_WPF_WinForms
  14. {
  15. 	/// <summary>
  16. 	/// Interaction logic for About.xaml
  17. 	/// </summary>
  18. 	public partial class AboutDialog : Window
  19. 	{
  20. 		public AboutDialog()
  21. 		{
  22. 			this.InitializeComponent();
  23.  
  24.             CommandBinding aBind_Ok = new CommandBinding( IECommands.AboutOk );//CommandBinding 用于将命令（例如按钮点击）与事件处理程序（例如方法）关联起来。当命令执行时，与之关联的事件处理程序将被调用，从而执行相应的逻辑。这种机制使得开发人员可以在代码中定义一次命令处理逻辑，然后在需要的地方重用该逻辑，而不必在每个界面元素上都编写事件处理程序。
  25.             aBind_Ok.Executed += OkCommand_Executed;//这行代码将 OkCommand_Executed 方法添加为 aBind_Ok 对象的 Executed 事件的事件处理程序。换句话说，当 aBind_Ok 对象引发 Executed 事件时（例如，当与该命令关联的操作被触发时），OkCommand_Executed 方法将被调用来执行相应的逻辑。
  26.             aBind_Ok.CanExecute += OkCommand_CanExecute;//决定aBind_Ok.Executed是否能被执行
  27.             CommandBindings.Add(aBind_Ok);
  28.         }
  29.   
  30.         private void OkCommand_Executed( object sender, ExecutedRoutedEventArgs e )
  31.         {
  32.             this.Close();
  33.         }
  34.  
  35.         private void OkCommand_CanExecute(object sender, CanExecuteRoutedEventArgs e)
  36.         {
  37.             e.CanExecute = true;//设置为false则不可执行，如果把OkCommand_CanExecute相关的都注释掉，则默认为不可执行
  38.         }
  39.  
  40.     }
  41. }

2.iecommands

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Windows.Input;
  6.  
  7. namespace IE_WPF_WinForms
  8. {
  9.     public class IECommands
  10.     {
  11.         // 定义静态属性，表示不同的命令
  12.         public static RoutedUICommand New { get; private set; }
  13.         public static RoutedUICommand Close { get; private set; }
  14.         public static RoutedUICommand Quit { get; private set; }
  15.         public static RoutedUICommand About { get; private set; }
  16.         public static RoutedUICommand AboutOk { get; private set; }
  17.  
  18.         static IECommands()
  19.         {
  20.             #region menu
  21.  
  22.             // 创建新命令，并设置快捷键
  23.             InputGestureCollection inputsNew = new InputGestureCollection();
  24.             inputsNew.Add(new KeyGesture(Key.N, ModifierKeys.Control, "Ctrl + N"));
  25.             New = new RoutedUICommand("New", "New", typeof(IECommands), inputsNew);
  26.             
  27.             // 创建关闭命令
  28.             Close = new RoutedUICommand("Close", "Close", typeof(IECommands));
  29.  
  30.             // 创建退出命令，并设置快捷键
  31.             InputGestureCollection inputsQuit = new InputGestureCollection();
  32.             inputsQuit.Add(new KeyGesture(Key.F4, ModifierKeys.Alt, "Alt + F4"));
  33.             Quit = new RoutedUICommand("Quit", "Quit", typeof(IECommands), inputsQuit);
  34.  
  35.             // 创建关于命令，并设置快捷键
  36.             InputGestureCollection inputsAbout = new InputGestureCollection();
  37.             inputsAbout.Add(new KeyGesture(Key.F1));
  38.             About = new RoutedUICommand("About", "About", typeof(IECommands), inputsAbout);
  39.  
  40.             #endregion
  41.  
  42.             #region aboutDlg
  43.  
  44.             // 创建关于对话框确定命令，并设置快捷键
  45.             InputGestureCollection inputsAboutOk = new InputGestureCollection();
  46.             inputsAboutOk.Add(new KeyGesture(Key.Enter));
  47.             AboutOk = new RoutedUICommand("AboutOk", "AboutOk", typeof(IECommands), inputsAboutOk);
  48.  
  49.             #endregion
  50.         }
  51.     }
  52. }

这段代码定义了一个静态类 IECommands，其中包含了几个静态属性，每个属性表示一个命令。每个命令都是一个 RoutedUICommand 类型的对象，用于处理 WPF 应用程序中的命令操作。具体注释如下：

  • public static RoutedUICommand New { get; private set; }：表示新建命令。
  • public static RoutedUICommand Close { get; private set; }：表示关闭命令。
  • public static RoutedUICommand Quit { get; private set; }：表示退出命令。
  • public static RoutedUICommand About { get; private set; }：表示关于命令。
  • public static RoutedUICommand AboutOk { get; private set; }：表示关于对话框确定命令。

在静态构造函数中，每个命令对象都被实例化并初始化，其中包括命令名称、显示文本和快捷键等信息。

3.mainwindow.xaml

  1. <Window
  2.     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  <!-- 命名空间定义 -->
  3.     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  <!-- 命名空间定义 -->
  4.     x:Class="IE_WPF_WinForms.MainWindow"  <!-- 定义窗口类 -->
  5.     xmlns:local="clr-namespace:IE_WPF_WinForms"  <!-- 命名空间定义 -->
  6.     Title="Sample Import/Export" Height="600" Width="900" Icon="res/MainFrame.ico">  <!-- 窗口标题、大小、图标 -->
  7.  
  8.     <Window.Background>  <!-- 设置窗口背景 -->
  9.         <SolidColorBrush Color="{DynamicResource {x:Static SystemColors.ControlDarkColorKey}}"/>  <!-- 使用动态资源设置背景颜色 -->
  10.     </Window.Background>
  11. 	
  12. 	<Window.Resources>  <!-- 设置窗口资源 -->
  13.         <BooleanToVisibilityConverter x:Key="boolToVisibilityConverter"/>  <!-- 定义布尔值转换为可见性的转换器 -->
  14.     </Window.Resources>
  15. 		
  16.     <Grid>  <!-- 定义主体布局为网格 -->
  17. 	    <Grid.RowDefinitions>  <!-- 定义网格行 -->
  18.  			<RowDefinition Height="auto"/>  <!-- 第一行高度自适应 -->
  19. 			<RowDefinition Height="auto"/>  <!-- 第二行高度自适应 -->
  20. 			<RowDefinition />  <!-- 第三行高度为剩余空间 -->
  21. 			<RowDefinition Height="auto"/>  <!-- 第四行高度自适应 -->
  22. 		</Grid.RowDefinitions>
  23.         
  24.     	<Menu Height="25" Grid.Row="0">  <!-- 菜单栏，位于第一行 -->
  25.     		<MenuItem Header="File">  <!-- 文件菜单项 -->
  26.     			<MenuItem Command="local:IECommands.New"/>  <!-- 新建命令 -->
  27.     			<MenuItem Command="local:IECommands.Close"/>  <!-- 关闭命令 -->
  28. 				<MenuItem Header="Import" IsEnabled="{Binding RelativeSource={RelativeSource Mode=FindAncestor, AncestorType={x:Type Window}}, Path=IsDocumentOpen}">  <!-- 导入子菜单 -->
  29. 					<MenuItem Name="ImportBrep" Header="BRep..." Click="ImportBRep_Click"/>  <!-- BRep 导入选项 -->
  30. 					<MenuItem Name="ImportIges" Header="Iges..." Click="ImportIges_Click"/>  <!-- Iges 导入选项 -->
  31.                     <MenuItem Name="ImportStep" Header="Step..." Click="ImportStep_Click"/>  <!-- Step 导入选项 --在这段 XAML 代码中，最下面的 </MenuItem> 标签表示对 <MenuItem> 元素的闭合，它用于结束一个 MenuItem 的定义。>
  32. 				</MenuItem>
  33.                 <MenuItem Header="Export" IsEnabled="{Binding RelativeSource={RelativeSource Mode=FindAncestor, AncestorType={x:Type Window}}, Path=IsDocumentOpen}">  <!-- 导出子菜单 -->
  34. 					<MenuItem Name="ExportBrep" Header="BRep..." Click="ExportBRep_Click"/>  <!-- BRep 导出选项 -->
  35. 					<MenuItem Name="ExportIges" Header="Iges..." Click="ExportIges_Click"/>  <!-- Iges 导出选项 -->
  36. 					<MenuItem Name="ExportStep" Header="Step..." Click="ExportStep_Click"/>  <!-- Step 导出选项 -->
  37. 					<MenuItem Name="ExportStl" Header="Stl..." Click="ExportStl_Click"/>  <!-- Stl 导出选项 -->
  38. 					<MenuItem Name="ExportVrml" Header="Vrml..." Click="ExportVrml_Click"/>  <!-- Vrml 导出选项 -->
  39. 					<Separator/>  <!-- 分隔线 -->
  40. 					<MenuItem Name="ExportImage" Header="Image..." Click="ExportImage_Click"/>  <!-- 图像导出选项 -->
  41. 				</MenuItem>
  42.     			<Separator/>  <!-- 分隔线 -->
  43.     			<MenuItem Command="local:IECommands.Quit"/>  <!-- 退出命令 -->
  44.     		</MenuItem>
  45.     		<MenuItem Header="View">  <!-- 视图菜单项 -->
  46.     			<MenuItem Name="ActivateToolbar" IsCheckable="True" IsChecked="True" Header="Toolbar"/>  <!-- 工具栏显示/隐藏选项 -->
  47.     			<MenuItem Name="ActivateStatusbar" IsCheckable="True" IsChecked="True" Header="Statusbar"/>  <!-- 状态栏显示/隐藏选项 -->
  48.     		</MenuItem>
  49.     		<MenuItem Header="Help">  <!-- 帮助菜单项 -->
  50.     			<MenuItem Header="About" Command="local:IECommands.About"/>  <!-- 关于命令 -->
  51.     		</MenuItem>
  52.     	</Menu>
  53. 		
  54. 		<ToolBarTray Background="White" Grid.Row="1">  <!-- 工具栏托盘，位于第二行 -->
  55.             <ToolBar Name="ToolBar" Band="1" BandIndex="1"  <!-- 工具栏 -->
  56. 					 Visibility="{Binding ElementName=ActivateToolbar, Path=IsChecked, Converter={StaticResource boolToVisibilityConverter}}"  <!-- 根据绑定的可见性属性显示/隐藏工具栏 -->
  57.                      MouseEnter="ToolBar_MouseEnter" MouseLeave="ToolBar_MouseLeave">  <!-- 鼠标进入/离开事件 -->
  58.                 <Button ToolTip="New" Command="local:IECommands.New">  <!-- 新建按钮 -->
  59.                     <Image Source="res/new.png" Style="{StaticResource toolbarImageStyle}"/>  <!-- 图像 -->
  60.                 </Button>
  61.         		<Button ToolTip="About" Command="local:IECommands.About">  <!-- 关于按钮 -->
  62.                     <Image Source="res/help.png" Style="{StaticResource toolbarImageStyle}"/>  <!-- 图像 -->
  63.                 </Button>
  64.         	</ToolBar>
  65. 			<!-- 其他工具栏按钮省略 -->
  66.         </ToolBarTray>
  67.         
  68. 		<TabControl Name="ViewPanel" Grid.Row="2"  <!-- 标签页控件，位于第三行 -->
  69.                     SelectionChanged="OnViewerChanged"  <!-- 选择改变事件 -->
  70.                     Visibility="{Binding RelativeSource={RelativeSource Mode=FindAncestor, AncestorType={x:Type Window}}, Path=IsDocumentOpen, Converter={StaticResource boolToVisibilityConverter}}">  <!-- 根据绑定的可见性属性显示/隐藏标签页 -->
  71.             
  72.             <TabControl.ContextMenu>  <!-- 标签页右键菜单 -->
  73.                 <ContextMenu>
  74.                     <MenuItem Command="local:IECommands.New" Style="{StaticResource popupItem}"/>  <!-- 新建命令 -->
  75.                     <MenuItem Command="local:IECommands.Close" Style="{StaticResource popupItem}"/>  <!-- 关闭命令 -->
  76.                 </ContextMenu>
  77.             </TabControl.ContextMenu>
  78.             
  79. 		</TabControl>
  80.         
  81.         <StatusBar Background="White"  Grid.Row="3" Visibility="{Binding ElementName=ActivateStatusbar, Path=IsChecked, Converter={StaticResource boolToVisibilityConverter}}">  <!-- 状态栏，位于第四行 -->
  82.         	<TextBlock Text="{Binding RelativeSource={RelativeSource Mode=FindAncestor, AncestorType={x:Type Window}}, Path=StatusBarText}"/>  <!-- 状态栏文本 -->
  83. 		</StatusBar>
  84.     </Grid>
  85. </Window>

4.mainwindow.xaml.cs

  1. using System.Text;  // 导入System.Text命名空间
  2. using System.Windows;  // 导入System.Windows命名空间
  3. using System.Windows.Controls;  // 导入System.Windows.Controls命名空间
  4. using System.Windows.Data;  // 导入System.Windows.Data命名空间
  5. using System.Windows.Documents;  // 导入System.Windows.Documents命名空间
  6. using System.Windows.Input;  // 导入System.Windows.Input命名空间
  7. using System.Windows.Media;  // 导入System.Windows.Media命名空间
  8. using System.Windows.Media.Imaging;  // 导入System.Windows.Media.Imaging命名空间
  9. using System.Windows.Navigation;  // 导入System.Windows.Navigation命名空间
  10. using System.Windows.Shapes;  // 导入System.Windows.Shapes命名空间
  11. using System.ComponentModel;  // 导入System.ComponentModel命名空间
  12. using System.Windows.Forms.Integration;  // 导入System.Windows.Forms.Integration命名空间
  13.  
  14. namespace IE_WPF_WinForms
  15. {
  16.     /// <summary>
  17.     /// Interaction logic for MainWindow.xaml
  18.     /// </summary>
  19.     public partial class MainWindow : Window, INotifyPropertyChanged  // 定义MainWindow类，继承自Window类，实现了INotifyPropertyChanged接口
  20.     {
  21.         public event PropertyChangedEventHandler PropertyChanged;  // PropertyChanged事件，用于通知属性更改
  22.         protected void RaisePropertyChanged(string thePropertyName)  // 属性更改通知方法
  23.         {
  24.             if (PropertyChanged != null)
  25.             {
  26.                 PropertyChanged(this, new PropertyChangedEventArgs(thePropertyName));
  27.             }
  28.         }
  29.  
  30.         // 构造函数
  31.         public MainWindow()
  32.         {
  33.             InitializeComponent();  // 初始化窗口组件
  34.  
  35.             // 初始化属性值
  36.             StatusBarText = String.Empty;
  37.             IsHlrOffPushed = false;
  38.             IsHlrOnPushed = true;
  39.             IsZoomWinEnabled = true;
  40.  
  41.             // 添加命令绑定
  42.             #region menu operations
  43.             // 添加New命令绑定
  44.             CommandBinding aBind_New = new CommandBinding(IECommands.New);
  45.             aBind_New.Executed += NewCommand_Executed;
  46.             CommandBindings.Add(aBind_New);
  47.  
  48.             // 添加Close命令绑定
  49.             CommandBinding aBind_Close = new CommandBinding(IECommands.Close);
  50.             aBind_Close.Executed += CloseCommand_Executed;
  51.             aBind_Close.CanExecute += CloseCommand_CanExecute;
  52.             CommandBindings.Add(aBind_Close);
  53.  
  54.             // 添加Quit命令绑定
  55.             CommandBinding aBind_Quit = new CommandBinding(IECommands.Quit);
  56.             aBind_Quit.Executed += QuitCommand_Executed;
  57.             CommandBindings.Add(aBind_Quit);
  58.  
  59.             // 添加About命令绑定
  60.             CommandBinding aBind_About = new CommandBinding(IECommands.About);
  61.             aBind_About.Executed += AboutCommand_Executed;
  62.             CommandBindings.Add(aBind_About);
  63.             # endregion
  64.  
  65.             PreviewKeyDown += new KeyEventHandler(OnPreviewKeyDown);  // 添加键盘按下事件处理程序
  66.             PreviewKeyUp += new KeyEventHandler(OnPreviewKeyUp);  // 添加键盘释放事件处理程序
  67.         }
  68.  
  69.         // 状态栏文本属性
  70.         private String myStatusBarText;
  71.         public String StatusBarText
  72.         {
  73.             get
  74.             {
  75.                 return myStatusBarText;
  76.             }
  77.             private set
  78.             {
  79.                 myStatusBarText = value;
  80.                 RaisePropertyChanged("StatusBarText");
  81.             }
  82.         }
  83.  
  84.         // HlrOff按钮状态属性
  85.         private bool isHlrOffPushed;
  86.         public Boolean IsHlrOffPushed
  87.         {
  88.             get
  89.             {
  90.                 return isHlrOffPushed;
  91.             }
  92.             set
  93.             {
  94.                 isHlrOffPushed = value;
  95.                 RaisePropertyChanged("isHlrOffPushed");
  96.             }
  97.         }
  98.  
  99.         // HlrOn按钮状态属性
  100.         private bool isHlrOnPushed;
  101.         public Boolean IsHlrOnPushed
  102.         {
  103.             get
  104.             {
  105.                 return isHlrOnPushed;
  106.             }
  107.             set
  108.             {
  109.                 isHlrOnPushed = value;
  110.                 RaisePropertyChanged("IsHlrOnPushed");
  111.             }
  112.         }
  113.  
  114.         // ZoomWin按钮状态属性
  115.         private bool isZoomWinEnabled;
  116.         public Boolean IsZoomWinEnabled
  117.         {
  118.             get
  119.             {
  120.                 return isZoomWinEnabled;
  121.             }
  122.             set
  123.             {
  124.                 isZoomWinEnabled = value;
  125.                 RaisePropertyChanged("IsZoomWinEnabled");
  126.             }
  127.         }
  128.  
  129.         // 获取当前活动的OCCViewer
  130.         private OCCViewer ActiveViewer
  131.         {
  132.             get
  133.             {
  134.                 if (!IsDocumentOpen)
  135.                 {
  136.                     return null;
  137.                 }
  138.  
  139.                 WindowsFormsHost aHost = (ViewPanel.SelectedContent) as WindowsFormsHost;
  140.                 if (aHost == null)
  141.                 {
  142.                     return null;
  143.                 }
  144.  
  145.                 return aHost.Child as OCCViewer;
  146.             }
  147.         }
  148.  
  149.         // 判断文档是否打开属性
  150.         public Boolean IsDocumentOpen
  151.         {
  152.             get
  153.             {
  154.                 return ViewPanel.Items.Count > 0;
  155.             }
  156.         }
  157.  
  158.         // 新文档计数器
  159.         private int myDocumentCounter = 1;
  160.  
  161.         // New命令执行方法
  162.         private void NewCommand_Executed(object sender, ExecutedRoutedEventArgs e)
  163.         {
  164.             // 创建新文档
  165.             WindowsFormsHost aHost = new WindowsFormsHost();
  166.             OCCViewer aForm = new OCCViewer();
  167.             aForm.Show();
  168.             aHost.Child = aForm;
  169.  
  170.             TabItem aNewTab = new TabItem();
  171.             aNewTab.Content = aHost;
  172.             aNewTab.IsSelected = true;
  173.             aNewTab.Header = "Document " + myDocumentCounter.ToString();
  174.             myDocumentCounter++;
  175.  
  176.             ViewPanel.Items.Add(aNewTab);
  177.  
  178.             // 更新XAML属性
  179.             RaisePropertyChanged("IsDocumentOpen");
  180.         }
  181.  
  182.         // Close命令执行方法
  183.         private void CloseCommand_Executed(object sender, ExecutedRoutedEventArgs e)
  184.         {
  185.             if (ViewPanel.Items.Count > 0)
  186.             {
  187.                 ViewPanel.Items.Remove(ViewPanel.SelectedItem);
  188.             }
  189.  
  190.             // 更新XAML属性
  191.             RaisePropertyChanged("IsDocumentOpen");
  192.         }
  193.  
  194.         // Close命令执行时是否可执行方法
  195.         private void CloseCommand_CanExecute(object sender, CanExecuteRoutedEventArgs e)
  196.         {
  197.             e.CanExecute = IsDocumentOpen;
  198.         }
  199.  
  200.         // Quit命令执行方法
  201.         private void QuitCommand_Executed(object sender, ExecutedRoutedEventArgs e)
  202.         {
  203.             this.Close();
  204.         }
  205.  
  206.         // ImportBRep按钮点击事件处理方法
  207.         private void ImportBRep_Click(object sender, RoutedEventArgs e)
  208.         {
  209.             if (ActiveViewer != null)
  210.             {
  211.                 ActiveViewer.ImportModel(ModelFormat.BREP);
  212.             }
  213.         }
  214.  
  215.         // ImportIges按钮点击事件处理方法
  216.         private void ImportIges_Click(object sender, RoutedEventArgs e)
  217.         {
  218.             if (ActiveViewer != null)
  219.             {
  220.                 ActiveViewer.ImportModel(ModelFormat.IGES);
  221.             }
  222.         }
  223.  
  224.         // ImportStep按钮点击事件处理方法
  225.         private void ImportStep_Click(object sender, RoutedEventArgs e)
  226.         {
  227.             if (ActiveViewer != null)
  228.             {
  229.                 ActiveViewer.ImportModel(ModelFormat.STEP);
  230.             }
  231.         }
  232.  
  233.         // ExportBRep按钮点击事件处理方法
  234.         private void ExportBRep_Click(object sender, RoutedEventArgs e)
  235.         {
  236.             if (ActiveViewer != null)
  237.             {
  238.                 ActiveViewer.ExportModel(ModelFormat.BREP);
  239.             }
  240.         }
  241.  
  242.         // ExportStep按钮点击事件处理方法
  243.         private void ExportStep_Click(object sender, RoutedEventArgs e)
  244.         {
  245.             if (ActiveViewer != null)
  246.             {
  247.                 ActiveViewer.ExportModel(ModelFormat.STEP);
  248.             }
  249.         }
  250.  
  251.         // ExportIges按钮点击事件处理方法
  252.         private void ExportIges_Click(object sender, RoutedEventArgs e)
  253.         {
  254.             if (ActiveViewer != null)
  255.             {
  256.                 ActiveViewer.ExportModel(ModelFormat.IGES);
  257.             }
  258.         }
  259.  
  260.         // ExportStl按钮点击事件处理方法
  261.         private void ExportStl_Click(object sender, RoutedEventArgs e)
  262.         {
  263.             if (ActiveViewer != null)
  264.             {
  265.                 ActiveViewer.ExportModel(ModelFormat.STL);
  266.             }
  267.         }
  268.  
  269.         // ExportVrml按钮点击事件处理方法
  270.         private void ExportVrml_Click(object sender, RoutedEventArgs e)
  271.         {
  272.             if (ActiveViewer != null)
  273.             {
  274.                 ActiveViewer.ExportModel(ModelFormat.VRML);
  275.             }
  276.         }
  277.  
  278.         // ExportImage按钮点击事件处理方法
  279.         private void ExportImage_Click(object sender, RoutedEventArgs e)
  280.         {
  281.             if (ActiveViewer != null)
  282.             {
  283.                 ActiveViewer.ExportModel(ModelFormat.IMAGE);
  284.             }
  285.         }
  286.  
  287.         // FitAll按钮点击事件处理方法
  288.         private void FitAllBtn_Click(object sender, RoutedEventArgs e)
  289.         {
  290.             if (ActiveViewer != null)
  291.             {
  292.                 ActiveViewer.FitAll();
  293.             }
  294.         }
  295.  
  296.         // ZoomWindow按钮点击事件处理方法
  297.         private void ZoomWindowBtn_Click(object sender, RoutedEventArgs e)
  298.         {
  299.             if (ActiveViewer != null)
  300.             {
  301.                 IsZoomWinEnabled = false;
  302.                 ActiveViewer.ZoomWindow();
  303.             }
  304.         }
  305.  
  306.         // DynamicZooming按钮点击事件处理方法
  307.         private void DynamicZoomingBtn_Click(object sender, RoutedEventArgs e)
  308.         {
  309.             if (ActiveViewer != null)
  310.             {
  311.                 ActiveViewer.DynamicZooming();
  312.             }
  313.         }
  314.  
  315.         // DynamicPanning按钮点击事件处理方法
  316.         private void DynamicPanningBtn_Click(object sender, RoutedEventArgs e)
  317.         {
  318.             if (ActiveViewer != null)
  319.             {
  320.                 ActiveViewer.DynamicPanning();
  321.             }
  322.         }
  323.  
  324.         // GlobalPanning按钮点击事件处理方法
  325.         private void GlobalPanningBtn_Click(object sender, RoutedEventArgs e)
  326.         {
  327.             if (ActiveViewer != null)
  328.             {
  329.                 ActiveViewer.GlobalPanning();
  330.             }
  331.         }
  332.  
  333.         // FrontBtn按钮点击事件处理方法
  334.         private void FrontBtn_Click(object sender, RoutedEventArgs e)
  335.         {
  336.             if (ActiveViewer != null)
  337.             {
  338.                 ActiveViewer.FrontView();
  339.             }
  340.         }
  341.  
  342.         // BackBtn按钮点击事件处理方法
  343.         private void BackBtn_Click(object sender, RoutedEventArgs e)
  344.         {
  345.             if (ActiveViewer != null)
  346.             {
  347.                 ActiveViewer.BackView();
  348.             }
  349.         }
  350.  
  351.         // TopBtn按钮点击事件处理方法
  352.         private void TopBtn_Click(object sender, RoutedEventArgs e)
  353.         {
  354.             if (ActiveViewer != null)
  355.             {
  356.                 ActiveViewer.TopView();
  357.             }
  358.         }
  359.  
  360.         // BottomBtn按钮点击事件处理方法
  361.         private void BottomBtn_Click(object sender, RoutedEventArgs e)
  362.         {
  363.             if (ActiveViewer != null)
  364.             {
  365.                 ActiveViewer.BottomView();
  366.             }
  367.         }
  368.  
  369.         // LeftBtn按钮点击事件处理方法
  370.         private void LeftBtn_Click(object sender, RoutedEventArgs e)
  371.         {
  372.             if (ActiveViewer != null)
  373.             {
  374.                 ActiveViewer.LeftView();
  375.             }
  376.         }
  377.  
  378.         // RightBtn按钮点击事件处理方法
  379.         private void RightBtn_Click(object sender, RoutedEventArgs e)
  380.         {
  381.             if (ActiveViewer != null)
  382.             {
  383.                 ActiveViewer.RightView();
  384.             }
  385.         }
  386.  
  387.         // AxoBtn按钮点击事件处理方法
  388.         private void AxoBtn_Click(object sender, RoutedEventArgs e)
  389.         {
  390.             if (ActiveViewer != null)
  391.             {
  392.                 ActiveViewer.AxoView();
  393.             }
  394.         }
  395.  
  396.         // ResetBtn按钮点击事件处理方法
  397.         private void ResetBtn_Click(object sender, RoutedEventArgs e)
  398.         {
  399.             if (ActiveViewer != null)
  400.             {
  401.                 ActiveViewer.Reset();
  402.             }
  403.         }
  404.  
  405.         // DynamicRotationBtn按钮点击事件处理方法
  406.         private void DynamicRotationBtn_Click(object sender, RoutedEventArgs e)
  407.         {
  408.             if (ActiveViewer != null)
  409.             {
  410.                 ActiveViewer.DynamicRotation();
  411.             }
  412.         }
  413.  
  414.         // HiddenOffBtn按钮点击事件处理方法
  415.         private void HiddenOffBtn_Click(object sender, RoutedEventArgs e)
  416.         {
  417.             IsHlrOffPushed = true;
  418.             IsHlrOnPushed = false;
  419.             if (ActiveViewer != null)
  420.             {
  421.                 ActiveViewer.HiddenOff();
  422.             }
  423.         }
  424.  
  425.         // HiddenOnBtn按钮点击事件处理方法
  426.         private void HiddenOnBtn_Click(object sender, RoutedEventArgs e)
  427.         {
  428.             IsHlrOffPushed = false;
  429.             IsHlrOnPushed = true;
  430.             if (ActiveViewer != null)
  431.             {
  432.                 ActiveViewer.HiddenOn();
  433.             }
  434.         }
  435.  
  436.         // About命令执行方法
  437.         private void AboutCommand_Executed(object sender, ExecutedRoutedEventArgs e)
  438.         {
  439.             AboutDialog aDlg = new AboutDialog();
  440.             aDlg.ShowDialog();
  441.         }
  442.  
  443.         // Toolbar鼠标进入事件处理方法
  444.         private void ToolBar_MouseEnter(object sender, MouseEventArgs e)
  445.         {
  446.             StatusBarText = "Toolbar";
  447.         }
  448.  
  449.         // DocumentToolBar鼠标进入事件处理方法
  450.         private void DocumentToolBar_MouseEnter(object sender, MouseEventArgs e)
  451.         {
  452.             StatusBarText = "Document toolbar";
  453.         }
  454.  
  455.         // ViewToolBar鼠标进入事件处理方法
  456.         private void ViewToolBar_MouseEnter(object sender, MouseEventArgs e)
  457.         {
  458.             StatusBarText = "View toolbar";
  459.         }
  460.  
  461.         // Toolbar鼠标离开事件处理方法
  462.         private void ToolBar_MouseLeave(object sender, MouseEventArgs e)
  463.         {
  464.             StatusBarText = "";
  465.         }
  466.  
  467.         // 缩放完成事件处理方法
  468.         public void OnZoomingFinished(object sender, EventArgs e)
  469.         {
  470.             IsZoomWinEnabled = true;
  471.         }
  472.  
  473.         // 是否启用Wireframe属性
  474.         public bool IsWireframeEnabled
  475.         {
  476.             get
  477.             {
  478.                 if (ActiveViewer != null)
  479.                 {
  480.                     return ActiveViewer.IsWireframeEnabled;
  481.                 }
  482.                 return false;
  483.             }
  484.         }
  485.  
  486.         // Wireframe按钮点击事件处理方法
  487.         private void Wireframe_Click(object sender, RoutedEventArgs e)
  488.         {
  489.             if (ActiveViewer != null)
  490.             {
  491.                 ActiveViewer.Wireframe();
  492.             }
  493.         }
  494.  
  495.         // Shading按钮点击事件处理方法
  496.         private void Shading_Click(object sender, RoutedEventArgs e)
  497.         {
  498.             if (ActiveViewer != null)
  499.             {
  500.                 ActiveViewer.Shading();
  501.             }
  502.         }
  503.  
  504.         // 是否启用Shading属性
  505.         public bool IsShadingEnabled
  506.         {
  507.             get
  508.             {
  509.                 if (ActiveViewer != null)
  510.                 {
  511.                     return ActiveViewer.IsShadingEnabled;
  512.                 }
  513.                 return false;
  514.             }
  515.         }
  516.  
  517.         // Color按钮点击事件处理方法
  518.         private void Color_Click(object sender, RoutedEventArgs e)
  519.         {
  520.             if (ActiveViewer != null)
  521.             {
  522.                 ActiveViewer.Color();
  523.             }
  524.         }
  525.  
  526.         // 是否启用Color属性
  527.         public bool IsColorEnabled
  528.         {
  529.             get
  530.             {
  531.                 if (ActiveViewer != null)
  532.                 {
  533.                     return ActiveViewer.IsColorEnabled;
  534.                 }
  535.                 return false;
  536.             }
  537.         }
  538.  
  539.         // Material按钮点击事件处理方法
  540.         private void Material_Click(object sender, RoutedEventArgs e)
  541.         {
  542.             if (ActiveViewer != null)
  543.             {
  544.                 ActiveViewer.Material();
  545.             }
  546.         }
  547.  
  548.         // 是否启用Material属性
  549.         public bool IsMaterialEnabled
  550.         {
  551.             get
  552.             {
  553.                 if (ActiveViewer != null)
  554.                 {
  555.                     return ActiveViewer.IsMaterialEnabled;
  556.                 }
  557.                 return false;
  558.             }
  559.         }
  560.  
  561.         // Transparency按钮点击事件处理方法
  562.         private void Transparency_Click(object sender, RoutedEventArgs e)
  563.         {
  564.             if (ActiveViewer != null)
  565.             {
  566.                 ActiveViewer.Transparency();
  567.             }
  568.         }
  569.  
  570.         // 是否启用Transparency属性
  571.         public bool IsTransparencyEnabled
  572.         {
  573.             get
  574.             {
  575.                 if (ActiveViewer != null)
  576.                 {
  577.                     return ActiveViewer.IsTransparencyEnabled;
  578.                 }
  579.                 return false;
  580.             }
  581.         }
  582.  
  583.         // Delete按钮点击事件处理方法
  584.         private void Delete_Click(object sender, RoutedEventArgs e)
  585.         {
  586.             if (ActiveViewer != null)
  587.             {
  588.                 ActiveViewer.Delete();
  589.             }
  590.         }
  591.  
  592.         // 是否启用Delete属性
  593.         public bool IsDeleteEnabled
  594.         {
  595.             get
  596.             {
  597.                 if (ActiveViewer != null)
  598.                 {
  599.                     return ActiveViewer.IsDeleteEnabled;
  600.                 }
  601.                 return false;
  602.             }
  603.         }
  604.  
  605.         // 工具栏操作可用性改变时更新属性
  606.         private void AvaliabiltyOfOperationToolbarChanged()
  607.         {
  608.             RaisePropertyChanged("IsWireframeEnabled");
  609.             RaisePropertyChanged("IsShadingEnabled");
  610.             RaisePropertyChanged("IsTransparencyEnabled");
  611.             RaisePropertyChanged("IsColorEnabled");
  612.             RaisePropertyChanged("IsMaterialEnabled");
  613.             RaisePropertyChanged("IsDeleteEnabled");
  614.         }
  615.  
  616.         // 操作可用性改变事件处理方法
  617.         public void OnAvaliabiltyOfOperationsChanged(object sender, EventArgs e)
  618.         {
  619.             AvaliabiltyOfOperationToolbarChanged();
  620.         }
  621.  
  622.         // 视图更改事件处理方法
  623.         private void OnViewerChanged(object sender, SelectionChangedEventArgs e)
  624.         {
  625.             if (e.RemovedItems.Count > 0)
  626.             {
  627.                 WindowsFormsHost aHost = ((e.RemovedItems[0] as TabItem).Content) as WindowsFormsHost;
  628.                 if (aHost == null)
  629.                 {
  630.                     return;
  631.                 }
  632.                 OCCViewer aViewer = aHost.Child as OCCViewer;
  633.                 if (aViewer != null)
  634.                 {
  635.                     aViewer.ZoomingFinished -= new EventHandler(OnZoomingFinished);
  636.                     aViewer.AvaliabiltyOfOperationsChanged -= new EventHandler(OnAvaliabiltyOfOperationsChanged);
  637.                 }
  638.             }
  639.  
  640.             if (e.AddedItems.Count > 0)
  641.             {
  642.                 WindowsFormsHost aHost = ((e.AddedItems[0] as TabItem).Content) as WindowsFormsHost;
  643.                 if (aHost == null)
  644.                 {
  645.                     return;
  646.                 }
  647.                 OCCViewer aViewer = aHost.Child as OCCViewer;
  648.                 if (aViewer != null)
  649.                 {
  650.                     aViewer.ZoomingFinished += new EventHandler(OnZoomingFinished);
  651.                     aViewer.AvaliabiltyOfOperationsChanged += new EventHandler(OnAvaliabiltyOfOperationsChanged);
  652.                 }
  653.             }
  654.  
  655.             AvaliabiltyOfOperationToolbarChanged();
  656.         }
  657.  
  658.         // 键盘按下事件处理方法
  659.         private void OnPreviewKeyDown(object sender, KeyEventArgs args)
  660.         {
  661.             if (ActiveViewer != null)
  662.             {
  663.                 ActiveViewer.OnKeyDown(args.Key);
  664.             }
  665.         }
  666.  
  667.         // 键盘释放事件处理方法
  668.         private void OnPreviewKeyUp(object sender, KeyEventArgs args)
  669.         {
  670.             if (ActiveViewer != null)
  671.             {
  672.                 ActiveViewer.OnKeyUp();
  673.             }
  674.         }
  675.     }
  676. }

这段代码实现了一个包含多个选项卡的主窗口，每个选项卡中嵌套了Windows Forms控件。窗口中包含了各种命令和事件处理逻辑，用于控制图形视图的显示和交互。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/161875
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号