爱华网熟悉 Visual Studio 2005 开发环境
及 UG 二次开发工程项目创建的方法
一、实验目的
1、 了解和使用 Visual Studio2005 集成开发环境； 2、 熟悉 Visual Studio2005 环境的基本命令和功能键； 3、 掌握 UG 二次开发工程项目创建过程和方法； 4、 理解简单的 UG 二次开发程序结构。
二、实验内容
分别使用 UG/Open AppWizard 向导和 Win32 应用程序向导（DLL）的方法创建 UG 二次开发工程项目，并利用 Visual Studio 2005 集成环境来编辑、编译并运行 下面简单 UG 二次开发程序：
#include <uf.h> #include <uf_ui.h> /* 包含UF_initialize()和UF_terminate()函数原型的头文件*/ /* 包含uc1601()函数原型的头文件*/
extern void ufusr( char *param, int *retcod, int param_len ) { /* 获取UG/OPEN API的执行权限 */ if(UF_initialize()!=0) return; /* 弹出消息窗口，显示“Hello,UG!” */ uc1601("Hello,UG!",1); /* 释放UG/OPEN API的执行权限*/ UF_terminate();
}
三、实验步骤
1 利用 UG/Open AppWizard 向导
为便于了解 UG/Open API 的使用，下面将创建一个简单的应用开发程序，其 功能是在 UG 环境中显示一个消息对话框 “Hello,UG!” 运行平台为 Windows XP， 。
开发平台为 Visual Studio.Net 和 UG/NX4。
1.1 创建 UG 二次开发工程项目
利用 UG/Open AppWizard 向导创建工程项目，该向导是 UG 软件本身提供的 应用向导， 不支持 MFC， 常应用于辅助工具的开发。 下面将在 Visual Studio.Net 和 UG/NX3 开发平台上利用 UG/Open AppWizard 向导创建工程项目。 运行 Visual Studio.Net，新建一个项目，如图 1-1 所示。选择对话框中的 Templates 中的 NX Open Wizard 向导创建 UG 应用工程，在 Name 文本框中输入 工程名称“First Project”，在 Location 文本框中输入工程路径，然后单击 OK 按钮确定，NX Open Wizard（Overview）对话框，如图 1-2 所示。对话框将 提示当前项目的默认设置，如果用户接受当前默认设置，可以直接单击 Finish 按钮确定，此时向导将按默认设置创建工程项目。如果不接受当前默认设置，用 户可以通过 NX Open Wizard（Application Settings）对话框和 NX Open Wizard （Entry Points）对话框来进行修改，两个对话框分别如图 1-3 和图 1-4 所示。 NX Open Wizard（Application Settings）对话框可以让用户选择工程项目的运 行模式和编程语言，NX Open Wizard（Entry Points）对话框可以让用户选择程 序入口方式及卸载方式，最后单击 Finish 按钮确定。
图 1-1 新建项目对话框
图 1-2 NX Open Wizard(Overview)
图 1-3 NX Open Wizard(Application Settings)
图 1-4 NX Open Wizard(Entry Points)
1.2 建立程序
此时用户可以在生成的工程模板中添加代码，在 Visual Studio.Net 集成开 发环境中，打开 hello.cpp 文件代码窗口，输入代码并保存。输入代码如下：
#include <uf.h> #include <uf_ui.h> /* 包含UF_initialize()和UF_terminate()函数原型的头文件*/ /* 包含uc1601()函数原型的头文件*/
extern void ufusr( char *param, int *retcod, int param_len ) { /* 获取UG/OPEN API的执行权限 */ if(UF_initialize()!=0) return; /* 弹出消息窗口，显示“Hello,UG!” */ uc1601("Hello,UG!",1); /* 释放UG/OPEN API的执行权限*/ UF_terminate(); }
1.3 编译链接项目
点击主菜单 “生成→生成 First Project” 如图 1-5， ， 对项目 First Project
编译、链接，生成.dll 文件（文件位置在项目属性的“链接器→常规→输出文 件”中设置）。
图 1-5 编译链接项目
1.4 调试程序
方法一：在程序编译之后，首先在程序中设置断点，点击主菜单“调试→启 动”，如图 1-6 所示，启动 NX 系统。在 NX 系统中激活.dll 程序，程序进入调 试状态，F11 是逐语句调试，F10 是逐过程调试（注意，在调试程序之前，一定 对项目属性的调试进行设置）。
图 1-6 调试程序
方法二：在程序编译、代码中设置断点后，启动 UG NX4；回到 Visual Studio.Net 集成开发环境，点击主菜单“工具→调试进程”，系统打开“进程” 对话框，如图 1-7 所示，双击“可用进程”列表中“ugraf.exe”，系统打开“附 加进程”对话框，如图 1-8 所示，选择要调试程序类型为“Native”，单击“确 定”按钮，系统进入程序调试状态，按“F11”或“F10”进行逐语句或逐过程调 试。
图 1-7
图 1-8
1.5 运行应用程序
在 UG 界面中选择菜单 File→Execute→NX Open，在系统弹出的一个文件选 择对话框中选择应用程序“Hello UG.dll”。如图 1-9、图 1-10 所示。
图 1-9
图 1-10
图 1-11
2 利用 Win32 应用程序向导（DLL）
应用开发程序框架还可以采用 Win32 DLL 向导创建。Win32 DLL 向导创建 Windows 常规 DLL，它只能导出 C 样式函数，不能导出 C++类、成员函数和重载 函数，同 UG/Open AppWizard 向导创建工程项目一样不支持 MFC。利用 Win32 应用程序向导创建工程项目，包括两个步骤：新建项目和设置项目属性。 步骤一：新建项目 打开 Visual Studio.NET，选择新建项目菜单项，将显示如图 1-12 所示的 新建项目对话框。在项目类型框中选择 Visual C++项目下的 Win32 选项，在模 板框中选择 Win32 项目选项，在名称框中输入项目名称，在位置框中设置合适 的路径，单击确定按钮接受输入。
图 1-12 新建项目对话框
这时将显示如图 1-13 所示的 Win32 应用程序向导－UFSolution 对话框，选 择应用程序设置属性页，在其中选择 Dll，直接单击完成按钮建立新项目。
图 1-13 Win32 应用程序向导－UFSolution 对话框
新建的项目中将会有一些向导默认添加的文件，如图 1-14 所示。图中列出 了新建项目中已有的文件。
图 1-14
解决方案资源管理器图
步骤二：设置项目属性 选择项目菜单下的属性项，将显示如图 1-15 所示的 UFSolution 属性页。
图 1-15
项目属性页－常规
在图 1-15 中要确认项目默认值框中配置类型为动态库(.dll)，然后，选择 调试选项，将显示图 1-16。在图 1-16 中，将操作框中的命令项设置为系统中的 UG 执行文件，即 ugraf.exe，设置这一项的目的是为了便于程序的调试。
图 1-16 项目属性页－调试
接 下 来 ， 选 择 C/C++ 项 中 的 常 规 选 项 ， 将 附 加 包 含 目 录 设 置 为 $UGII_BASE_DIRUGOPENPP; $UGII_BASE_DIRUGOPEN，如图 1-17 所示。设置这 一项的目的是为了包含 UF 的一些头文件。
图 1-17 项目属性页－C/C++－常规
选择 C/C++项中的代码生成选项，将运行库设置为多线程调试 DLL (/MDd)， 如图 1-18 所示。
图 1-18 项目属性页－C/C++－代码生成
选择链接器项中的常规选项，设置输出文件，将附加库目录设置为
$UGII_BASE_DIRUGOPEN; $UGII_BASE_DIRUGOPENPP，如图 1-19 所示。
图 1-19 项目属性页－链接器－常规
选 择 链 接 器 项 中 的 输 入 选 项 ， 设 置 附 加 依 赖 项 为 libufun.lib libugopenint.lib。这两个文件是在进行 UG 二次开发时必需的库载入文件，如 图 1-20 所示。
图 1-20 项目属性页－链接器－输入
设置好以上选项后，按应用按钮，将所设置的属性应用于项目。
四、实验要求
1． 复习教材有关内容。 2． 掌握 UG 二次开发程序项目的建立、程序调试步骤。 3． 完成实验报告。
实验二
UIStyler、Menuscript 创建用户界面、菜单 和工具条
一、 实验目的
1、掌握利用 UIStyler 创建所需的对话框，熟练掌握对基本控件的访问； 2、掌握 MENU SCRIPT 菜单脚本语言，能够创建所需的菜单和工具条。
二、 实验内容
1 UIStyler 对话框的应用
本次实验将创建以下对话框：
菜单和工具条：
1.1 对话框的应用环境
UG 的 UIStyler 应用模块提供给用户可视化建立 UG 风格对话框的功能。在 UG 主菜单中选择菜单项“Application→User Interface Styler...”，进入 UIStyler 应用模块，UIStyler 可视化界面如图 2-1 所示。
控件编辑工 具 控 件 栏 基本对话 框
对象浏览 器 属性编辑 器 图 2-1 UIStyler 可视化界面
1.2 对话框设计
UIStyler 可视化界面包括基本对话框、对象浏览器、属性编辑器、控件栏 和控件编辑工具五部分。 用户在控件栏中选择控件后放置在基本对话框中，通过
对象浏览器查看在基本对话框中设置的控件对象信息、 利用控件编辑工具调整控 件布局，通过属性编辑器编辑对话框及指定控件的属性。 利用 UIStyler 创建对话框并保存，系统将自动生成三个文件： 1．*.c 文件：对话框 C 语言源文件的模板文件，用户复制该模板文件，补 充回调函数代码，将生成对话框应用程序文件，.dll 文件应放在应用程序主目 录的 startup 子目录下，在 UG 系统启动是加载； 2．*.h 文件：定义*.c 文件中函数原型的*.c 文件的头文件； 3．*.dlg 文件：对话框文件，该文件需要被复制到应用程序主目录的 application 子目录下，由用户应用程序调用。
1.3 对话框的应用步骤
（1）设计对话框界面草图； （2）利用 UIStyler 工具创建对话框； （3）设置对话框中的回调函数； （4）保存对话框； （5）将系统自动生成的对话框 C 语言模板文件复制到 VC++项目中； （6）修改 C 文件，添加回调函数代码，编译连接文件； （7）将对话框文件（.dlg）复制到相应的目录下，将共享库文件（.dll） 复制到相应的目录下； （8）运行、测试及调试应用程序。 具体每一步的详细介绍请参考系统帮助文件中 Tools→User Interface Styler。在 UIStyler 对话框开发过程中，涉及到编程的仅 5、6 两个步骤。
1.4 基本对话框
图 2-2 是一个最简单的对话框，由三个系统按钮和对话框标题组成。对话框 的属性包括基本属性、被选择属性和回调函数。
图 2-2 基本对话框
1、对话框基本属性 对话框的基本属性包括对话框标题、提示信息、对话框前线名称、调用对话 框的形式以及导航按钮等。 对话框标题（Dialog Title）：对话框标题显示在对话框的标题栏中。 提示信息（Cue）：对话框提示信息将显示在 UG 的提示栏中。 前缀名称（Prefix Name）：对话框前缀名称将作为所有对话框控件名和对
话框回调函数名的前缀，默认值为 CHANGE。注意：同一工程中的不同对话框应 选用不同的前缀名称。 对话框类型（Dialog Type）：对话框类型有 Bottom 和 Top 两种，Bottom 类型表明该对话框需使用导航按钮，Top 类型则相反，一般采用 Bottom 类型。 对话框调用点（Launch Dialog From）：对话框调用点是指对话框被调用的 位置和方式，包括回调函数调用、菜单调用、User Exit 调用和所有调用方式。 导航按钮设置（Navigation Buttons）：UIStyler 提供了 OK、BACK、APPLY 和 CANCEL4 种导航按钮。对所有的对话框，OK 和 CANCEL 按钮都是必须的。对已 经选择的导航按钮， 还可以指定其激活状态。在导航按钮激活栏里没有被激活的 导航按钮，在对话框被调用时，按钮是不能被单击的。 对话框尺寸（Allow Dialog to Resize）：当对话框的允许尺寸改变属性被 设置时，对话框在调用时，允许用户改变对话框的尺寸。 2、对话框选择属性 对话框的选择属性包含了对话框激活开关、 对话框选择方式和对话框选择范 围定义。 选择方式定义了在当前对话框被激活时，在窗口中选择对象的方式是否 变化。其共有 3 种，即无变化（继承上次选择操作的属性定义）、单选、鲁棒选 择等。选择范围定义了当前对话框被激活时，被选择对象所有范围是否变化。其 有 4 种方式，即不变化、在装配中、仅在工作部件中、在工作部件和子装配中。 2、对话框基本回调函数 所有对话框都有 6 种基本回调函数， 它们分别是 APPLY 按钮的回调函数、 BACK 按钮的回调函数、CANCEL 按钮的回调函数、OK 按钮的回调函数、对话框构造函 数和对话框析构函数。对话框构造函数在 UG 构造对话框完成之后，用户应用执 行之前调用。 由于此时对话框上的所有控件都可以被使用，因此构造函数是初始 化对话框的最佳位置。对话框析构函函数是在 UG 对话框关闭之前被调用，此时， 对话框中的控件仍然可以被访问到。 对话框析构函数为用户提供了诸如释放内存 等析构操作的位置。
2 菜单文件 2.1 环境变量设置
UG 系统在起动的时候，是通过环境变量实现来获得系统菜单文件、用户菜 单文件以及来识别这两类文件。系统环境变量可以在文件 ugii_env.dat 中找到 定义， 若要修改时， 也可以在这个文件中修改， 但要注意最好保持系统定义的值。 1、系统默认的路径与环境变量 系统默认的主菜单文件 ug_main.men、 弹出式菜单文件 ug_view_popup.men、 与应用相关的菜单文件的位置由三个环境变量控制，如下表所示：
表 2-1 与系统菜单文件相关的环境变量 环境变量 UGII_DEFAULT_MENU_DIR UGII_MAIN_MENU_FILE UGII_VIEW_POPUP_MENU_FILE 描述 UG 的系统菜单文件所在的路径 默认值为$UGII_BASE_DIR/ugii/menus 主菜单文件的全路径 $UGII_DEFAULT_MENU_DIR/ug_main.men 弹出式菜单文件的全路径 $UGII_DEFAULT_MENU_DIR/ug_view_popup.men
环境变量 UGII_DEFAULT_MENU_DIR 的值不可更改。 环境变量 UGII_MAIN_MENU_FILE 和 UGII_VIEW_POPUP_MENU_FILE 的值可以更 改。 你可以把 ug_main.men 和 ug_view_popup.men 剪切到一个目录下，然后让这 两个环境变量指向这个目录，UG 仍然可以正确地加载菜单。 与应用相关的菜单文件是由应用的 APPLICATION_BUTTON 下的 MENU_FILES 指定的。 2、用户相关的路径与环境变量 当 UG 起动时， 它会从环境变量 UGII_CUSTOM_DIRECTORY_FILE 指定的文件 （默 认为$UGII_BASE_DIR/ugii/menus/custom_dirs.dat， 在文件 ugii_env.dat 中定 义） 中搜索用户接口定制文件 （包括用户菜单脚本文件， 工具条文件， 共享库等） 所在的路径。这样，用户就可以在 custom_dirs.dat 的文件未尾添加一行路径， 然后，将接口定制文件放在这个路径下（要创建与路径相应的文件夹），当 UG 起动时，就会像加载系统文件一样来加载用户的文件。 举个例子，当在 custom_dirs.dat 中添加了一行：D：UFSolution，就要建 立如图所示的文件夹：
图 2-3
添加文件夹 UFSolution
添加文件夹时，要求 UFSolution 及它子目录的名称中不能含有中文。
下面，让我们来看看 UFSolution 中的各个子目录的用途： ? ? ? ? startup：与整个 UG 系统应用都相关的文件存放的文件夹。其中的文件 在 UG 起动时自动加载。 application：与某个特定的应用模块相关的文件存放的文件夹。当进 入这些特定的模块时，其中的文件被自动动态加载。 bmp：存放用户的位图资源文件。 udo： 存放动态库文件。 动态库文件可以放在 udo 中， 也可以放在 startup 中，在 UG 起动时加载。 用户入口也以设置系统环境变量 UGII_VENDOR_DIR（或 UGII_SITE_DIR、 UGII_USER_DIR），使它为 D:UFSolution，这与上面的方法有同样的效果。 注意： 在文件 custom_dirs.dat 中可以添加多个路径，在这些路径所指向的 目录下，存放用户的接口定制文件，当有两个同名的接口定制文件存在时，就可 以发生冲突。这时，UG 是使用第一个被搜索到的接口定制文件，而忽略第二个。
2.2 定制
创建一个菜单通常使用编辑模式， 通过增加一个短的菜单文件去定制标准菜 单。使用附加菜单文件的方法定制菜单的一个优点是这些文件很容易地自动地装 被装载。 与应用无关的菜单文件放置在 startup 文件夹下，与应用相关的菜单文 件放置在相应的 application 文件夹下。 与应用相关的菜单文件在进入该应用时 将被加载。 另一个优点是在 UG 版本升级时更加容易,因为只有很小的附加菜单文 件需要修而不需要改动诸如 ug_main.men 的标准菜单文件。 附加菜单文件也使维 护更加方便，因这它们通常是一个很小的菜单文件。 菜单脚本文件(*.men)为文本文件，可以用记事本创建和编辑。菜单脚本文 件中指明了菜单位置、菜单项目名称及所调程序名称等。下面将在 UGNX 主菜单 的最后面添加“实例”->“创建垫圈...”菜单项为例，说明菜单的创建方法。 (1) 用 记 事 本 打 开 UG 安 装 目 录 下 的 UGIIugii_env.dat 文 件 ， 找 到 #UGII_USER_DIR=${HOME}行，去掉#和${HOME}，在=号后输入自己的目录，比如： E:exmaplemenu， 保存后退出此文件。这主要是告诉 UG 到那里去寻找用户定义 的菜单文件。 (2) 在用户目录(本例为 E:exmaplemenu)下新建两 个文件夹，取名为 startup 和 application。 (3)在 startup 目录下新建一个文本文件，输入以下内容，其中 ACTIONS 后 面跟的是需要调用的动态连接库或对话框文件(本例为 DianQuan.dlg). VERSION 120 !-----------------------------EDIT UG_GATEWAY_MAIN_MENUBAR TOP_MENU
CASCADE_BUTTON CUSTOM_MYMENU LABEL 实例 END_OF_TOP_MENU MENU CUSTOM_MYMENU BUTTON MAKE_GASKET LABEL 创建垫圈... ACTIONS DianQuan.dlg END_OF_MENU (4)把编译连接好的动态连接库文件（本例为 DianQuan.dlg）复制粘贴到 application 目录下。 (5)启动 UG，标题为“实例”的菜单出现在主菜单最后面，单击此下拉菜单， 再单击“创建垫圈...”菜单即可执行 DianQuan.dlg 文件。
3 工具条
工具栏（Toolbar）是一种用来快速实现用户常用功能的工具图标的集合， 它包括了一些常用的菜单命令。 用户可以根据需要自定义工具栏，形成自己的风 格。具体实现方法是制作或编写工具图标文件（BMP 文件）与工具栏文件，工具 栏文件是以.tbr 为扩展名的文本文件。UG 启动时载入工具栏文件，并根据文件 中的命令载入相应工具图标组成用户工具栏。 首先在用户工程路径下的 application 文件夹中创建工具图标文件，文件 名分别为 DianQuan.bmp，图标的标准大小为 24×24（像素×像素）。然后在用 户工程路径下的 startup 文件夹中创建工具栏脚本文件 DianQuan.tbr，并输入 如下代码： TITLE 实例 VERSION 170 !-----------------------------BUTTON MAKE_GASKET LABEL 创建垫圈 BITMAP DianQuan.bmp 各行含义如下： < 1 >工具栏的标题 < 2 >工具栏脚本文件的版本信息 < 3 >定义工具栏被导入时的起始位置， NO 、 TOP 、 BOTTOM 、 LEFT 和 有 RIGHT 5 种情况，分别表示起始位置为浮动、顶部、底部、左端和右端 < 4 >工具栏按钮的名称，与菜单脚本文件中相应菜单命令的名称相同 < 5 >工具按钮的标题 < 6 >工具按钮图标的文件名，默认路径为工程路径下的 application 文件
夹。
三、 实验要求
1、 写出程序，并调试程序，要给出测试数据和实验结果。 2、 整理上机步骤，总结经验和体会。 3、 完成实验报告和上交程序。
实验三
一、实验目的
外部数据库访问
1、掌握利用 API 文件操作函数访问外部数据，包括文本文件和电子表格； 2、掌握利用 ODBC 数据源访问外部数据。
二、实验内容
1 利用 ODBC 访问外部数据
ODBC（Open Database connectivity 开放式数据库互连）是由微软公司提 出的一个用于访问数据库的统一界面标准， 它提供了一个一致的应用程序编程接 口，该接口使用一个针对数据库的驱动程序与不同的数据库协同工作。 DSN（Data Source Name）是用于指定 ODBC 与相关的驱动程序相对应的一个 入口，所有 DSN 的信息由系统进行管理，一般来讲当应用程序要使用 ODBC 访问 数据库时，就需要指定一个 DSN 以便于连接到一个指定的 ODBC 驱动程序。 利用 ODBC 访问外部数据，首先要配置 ODBC 数据源，即创建 ODBC 的 DSN； 然后读取 ODBC 指定数据源中的数据。
1.1 配置 ODBC 数据源
1、选择"控制面板"中的"管理工具"下面的"数据源 (ODBC)"，如下图所示。
2、 在弹出的 ODBC 数据源管理器对话框中， 选择系统 “DSN” 并单击"添加?" ，
按钮，将出现创建新数据源对话框，如下图所示。
3、在创建新数据源对话框中，选择你将访问数据源相应的驱动程序，比如， 我 们 将 访 问 Access 数 据 库 中 的 数 据 ， 此 时 可 选 择 “ Microsoft Access Driver(*.mdb)” ，选择后，单击“完成”按钮，此时，出现数据源相应驱动程序 的选择界面，如下图所示。
4、在驱动程序选择界面中，数据源名框中输入 DSN 的名称，比如，Screw。 DSN 的名称非常重要，它是后期访问数据源的唯一标识。输入 DSN 的名称后，可 通过“选择(S) ?”按钮选择相应数据源所在的路径，如果选择成功，将在界面 出现已选中的数据源的完整路径和名称，如下图所示。
5、点击“确定”按钮，此时在“系统 DSN”中就会出现你刚创建的 ODBC 数 据源名，表明配置数据源成功。
1.2 读取 ODBC 数据源中的数据
读 取 ODBC 数 据 源 中 的 数 据 时 ， 经 常 使 用 到 CDatabase( 数 据 库 类 ) 、 CRecordSet(记录集类) 。CDatabase 类对象提供了对数据源的连接，通过它可 以对数据源进行操作。CRecordSet 类对象提供了从数据源中提取出的记录集进 行操作。 1、CDatabase 类
一个 CDatabase 对象代表与数据源的一个连接。 创建一个 CDatabase 对象之 后，调用 Open 或 OpenEx 成员函数指定一个 DSN（数据源名） 。一旦调用了这两 个函数之一，就建立起了与 DSN 的底层数据源的连接。CDatabase 对象通常与一 个或多个记录集（CRecordset 对象）一起使用。下面的例子是用一个 CDatabase 对象来建立与一个 DSN 的连接：
try{ CDatabase db; db.Open("Screw"); // 建立与DSN（Screw）的连接 // Use db ... db.Close(); //关闭先前建立的与DSN的连接 }
CDatabase 构造函数并没有做很多事情，只有调用 Open 函数才能建立起与 数据源的连接，因此，我们有必要先看一下这两个函数。
virtual BOOL Open( LPCTSTR lpszDSN, BOOL bExclusive = FALSE, BOOL bReadOnly = FALSE, LPCTSTR lpszConnect = _T("ODBC;"), BOOL bUseCursorLib = TRUE );
在 Open 函数原型中，有几个选项在打开数据库连接的时候可以指定，但通 常只需要提供第一个参数。 在前面的例子中，这第一个参数是我们在前面建立的 DSN 的名称。 bExclusive 参数指定是否允许其他应用程序对数据源的连接。bExclusive 为 FALSE 时表示允许多个程序共享打开的数据源。bExclusive 为 TRUE 时，在老 版本的类库中并不支持，会引发一个断言错误，在.net 中应该支持。 bReadOnly 参数允许应用程序指定建立连接之后，是否可以更新数据源。 FALSE 是默认值，表示可以通过这个连接来更新数据源。任何被创建并附属于这 个 CDatabase 的 CRecordset 对象都自动继承这个值。 lpszConnect 参数指定连接字符串。使用这个参数的好处是灵活性，如果数 据源指定了用户 ID 和密码， 可以通过 lpszConnect 参数来实现。上面的例子中， 如果我们的数据源指定了用户 ID 为 UgUser，密码为 110，那么可以有两种使用 Open 成员函数的方式：
db.Open( _T("Standard Part"), FALSE, FALSE, _T("ODBC;UID=UgUser;PSW=110"), FALSE
); db.Open( NULL, FALSE, FALSE, _T("DSN=Standard Part;UID=UgUser;PSW=110"), FALSE );
bUseCursorLib 参数指定是否使用 ODBC 游标库，如果这个值被设置为 TRUE （默认值） ，这个连接只允许静态快照或仅向前类型的游标。为了使用动态集， 这个参数必须设置为 FALSE。因为在后面我们要用到 CRecordset 类，所以上面 程序段中的 db.Open("Standard Pad")将会引起 CRecordset 类使用时的运行时 错误（虽然与 DSN 的连接通过这一条语句能建立好） ，原因是 bUseCursorLib 参 数未指定为 FALSE。 CDatabase::OpenEx 仅使用两个参数：一个连接字符串和一个代表连接选项 的 DWORD。lpszConnectString 向函数传递 ODBC 连接字符串，dwOptions 参数设 置这个连接的建立方式。下面的值可以通过逻辑操作符 OR 一起使用：
CDatabase::Exclusive CDatabase::openReadOnly CDatabase::useCursorLib CDatabase::noODBCDialog CDatabase::forceODBCDialog
这些值与在 Open 函数中的使用方法完全一样，唯一的区别是增加了 noODBCDialog 和 forceODBCDialog 标志。这些标志确定当应用程序企图建立与 数据源的连接时，ODBC Driver Manager 是否给用户弹出 ODBC 连接对话框。 2、CRecordset 类 一个 CDatabase 对象代表与数据源的一个连接， 而一个 CRecordset 对象 （称 为记录集）代表从一个数据源检索出的一组记录。 CRecordset 类支持动态集类型和快照类型。动态集，或称键集合驱动记录 集， 是数据的动态集合， 它支持双向滚动并与数据源的其他用户做的更新保持同 步。另一方面，快照则是在记录集被填充时数据的静态照片。这个记录集不受其 他用户所做的更改的影响。 如果使用快照类型记录集的应用程序需要查看其他用 户做的改动，必须先关闭记录集再重新打开。快照类型记录集也支持双向滚动。 创 建 一 个 记 录 集 最 快 捷 的 方 式 是 使 用 .net 框 架 向 程 序 中 添 加 一 个 CRecordset 类。首先，临时创建一个 MFC DLL 项目。然后，在类视图中，右键 单击项目名称，在弹出的菜单中，单击添加选项，选择添加类，此时将出现“Add Class”对话框，如下图所示。
在“Add Class”对话框中双击“MFC ODBC Consumer” ，得到下图所示的 MFC ODBC 使用者向导对话框。
单击“数据源”按钮，出现下图所示的选择数据源对话框,选择机器数据源 属性页。选择将访问的数据源，也可以通过“新建”按钮新建一个 ODBC 的 DSN。
当按“确定”按钮后，MFC ODBC 使用者向导对话框就会出现
接下来， 如果数据库文件 Standard_Part.mdb 有安全保护，就会弹出一个对 话框，要求输入该文件的用户 ID 和密码，然后又会弹出一个对话框，在这里， 我们选择表 Pad_Standard。单击确定，图 5-6 中的三个编辑框就不再是灰化的 了，其中分别出现类名 CPad_Standard，头文件名 Pad_Standard.h，源文件名 Pad_Standard.cpp，接受默认。 在上图中，可以选择记录集类型，我们选择动态集，并选中绑定所有列，单 击完成按钮。 至此，我们就向程序中添加了一个 CRecordset 的派生类 CPad_Standard,它 应该出现在类视图中。 使用 CPad_Standard 之前，有几点需要注意：
·在使用 CPad_Standard 类的文件中，要包含头文件 Pad_Standard.h · CPad_Standard 类的定义中， 在 它的几个数据成员 （分别代表 Pad_Standard 中的列）最好改成 CString 类型 ·要删去 Pad_Standard.cpp 中的密码明文 实例 3：MFC ODBC Consumer 向导自动生成的访问数据库文件
例 3-1 Pad_Standard.h
// Pad_Standard.h : CPad_Standard 的声明 #pragma once class CPad_Standard : public CRecordset { public: CPad_Standard(CDatabase* pDatabase = NULL); DECLARE_DYNAMIC(CPad_Standard) // 字段/参数数据 // 以下字符串类型(如果存在)反映数据库字段(ANSI 数据类型的 CStringA 和 // Unicode // 数据类型的 CStringW)的实际数据类型。 // 这是为防止 ODBC 驱动程序执行可能 // 不必要的转换。如果希望，可以将这些成员更改为 // CString 类型，ODBC 驱动程序将执行所有必要的转换。 // (注意: 必须使用 3.5 版或更高版本的 ODBC 驱动程序 // 以同时支持 Unicode 和这些转换)。 CStringW m_Serial_Number; CStringW m_Outer_Diameter; CStringW m_Inner_Diameter; CStringW m_Height; // 重写 // 向导生成的虚函数重写 public: virtual CString GetDefaultConnect(); // 默认连接字符串 virtual CString GetDefaultSQL(); // 记录集的默认 SQL virtual void DoFieldExchange(CFieldExchange* pFX); // RFX 支持 // 实现 #ifdef _DEBUG virtual void AssertValid() const; virtual void Dump(CDumpContext& dc) const;
#endif }; 清单 3－2
Pad_Standard.cpp
// Pad_Standard.h : CPad_Standard 类的实现 // CPad_Standard 实现 // 代码生成在 2004年5月18日, 20:09 #include "stdafx.h" #include "Pad_Standard.h" IMPLEMENT_DYNAMIC(CPad_Standard, CRecordset) CPad_Standard::CPad_Standard(CDatabase* pdb) : CRecordset(pdb) { m_Serial_Number = L""; m_Outer_Diameter = L""; m_Inner_Diameter = L""; m_Height = L""; m_nFields = 4; m_nDefaultType = dynaset; } #error Security Issue: The connection string may contain a password // 此连接字符串中可能包含密码 // 下面的连接字符串中可能包含明文密码和/或 // 其他重要信息。请在查看完 // 此连接字符串并找到所有与安全有关的问题后移除 #error。可能需要 // 将此密码存储为其他格式或使用其他的用户身份验证。 CString CPad_Standard::GetDefaultConnect() { return _T("DSN=Standard Part;DBQ=D:\DVLP\dt\standard_part.mdb;DriverId=25;FIL=MS Access;MaxBufferSize=2048;PageTimeout=5;PWD=8911;UID=admin;"); } CString CPad_Standard::GetDefaultSQL() { return _T("[Pad_Standard]"); } void CPad_Standard::DoFieldExchange(CFieldExchange* pFX) { pFX->SetFieldType(CFieldExchange::outputColumn);
// RFX_Text() 和 RFX_Int() 这类宏依赖的是 // 成员变量的类型，而不是数据库字段的类型。 // ODBC 尝试自动将列值转换为所请求的类型 RFX_Text(pFX, _T("[Serial_Number]"), m_Serial_Number); RFX_Text(pFX, _T("[Outer_Diameter]"), m_Outer_Diameter); RFX_Text(pFX, _T("[Inner_Diameter]"), m_Inner_Diameter); RFX_Text(pFX, _T("[Height]"), m_Height); } ///////////////////////////////////////////////////////////////////////////// // CPad_Standard 诊断 #ifdef _DEBUG void CPad_Standard::AssertValid() const { CRecordset::AssertValid(); } void CPad_Standard::Dump(CDumpContext& dc) const { CRecordset::Dump(dc); } #endif //_DEBUG
2 API 文件操作函数访问外部数据
UG/OPEN API 中有关文件操作的函数包含在头文件 uf_cfi.h 中，通过函数 uc4500 可以打开二进制文件，相关的文件操作函数有 uc4510、uc4511、uc4512、 uc4513 及 uc4520、uc4521、uc4522、uc4523，通过函数 uc4504 可以打开文本文 件，相关的文件操作函数有 uc4514、uc4524、uc4525，函数 uc4540 用于关闭文 件，判断文件是否存在使用函数 UF_CFI_ask_file_exist。 通过 UG/OPEN API 提供的文件操作函数访问外部数据时，要注意以下问题： （1）UG/Manager 和 TeamCenter 中的文件和文件夹操作不能使用 uf_cfi.h 中函数，在头文件 uf_ugmgr 中； （2）UG/OPEN API 中对文件和文件夹标识符的长度有如下限制： 文件名长度不能超过 UF_CFI_MAX_FILE_NAME_LEN； 文件夹路径的长度不能超过 UF_CFI_MAX_PATH_NAME_LEN； 整个文件路径的长度不能超过 UF_CFI_MAX_PATH_NAME_LEN。 访问文本文件的程序流程如下：
函数 uc4504 uc4514 uc4524 uc4540
描述 打开文本文件，该函数功能与 fopen 函数类似 从 uc4504 打开的文件中读取一行文本 写一行文本到由 uc4504 打开的文件中 关闭文件，该函数功能与 fclose 函数类似
实例 1：从用户界面到文本文件互相读写数据 该实例演示如何将用户在界面输入的数据写到文本文件中， 并将文本文件中 的内容输入到用户界面上。
（1）TxtAccess.men
VERSION 120 !-----------------------------EDIT UG_GATEWAY_MAIN_MENUBAR TOP_MENU CASCADE_BUTTON CUSTOM_TXTACC LABEL 外部数据访问 END_OF_TOP_MENU MENU CUSTOM_TXTACC BUTTON TXTACC LABEL 文本文件存取 ACTIONS TXTACC.dlg END_OF_MENU
（2）TxtAccess.h
#ifndef TXTACC_H_INCLUDED #define TXTACC_H_INCLUDED
#include <uf.h> #include <uf_defs.h> #include <uf_styler.h> #ifdef __cplusplus extern "C" { #endif #define TXTACC_MTXT_0 #define TXTACC_ACTION_2 #define TXTACC_ACTION_3 #define TXTACC_DIALOG_OBJECT_COUNT int TXTACC_action_2_act_cb ( int dialog_id, void * client_data, UF_STYLER_item_value_type_p_t callback_data); int TXTACC_action_3_act_cb ( int dialog_id, void * client_data, UF_STYLER_item_value_type_p_t callback_data); #ifdef __cplusplus } #endif #endif /* TXTACC_H_INCLUDED */ ("MTXT_0") ("ACTION_2") ("ACTION_3") (3)
（3）TxtAccess.cpp
#include <stdio.h> #include <uf.h> #include <uf_defs.h> #include <uf_exit.h> #include <uf_ui.h> #include <uf_styler.h> #include <uf_mb.h> #include <malloc.h> #include "TxtAccess.h" #define MAX_LINE_LEN (256+1)
#define TXTACC_CB_COUNT ( 2 + 1 ) /* Add 1 for the terminator */ static UF_STYLER_callback_info_t TXTACC_cbs[TXTACC_CB_COUNT] = { {TXTACC_ACTION_2 TXTACC_action_2_act_cb}, {TXTACC_ACTION_3 TXTACC_action_3_act_cb}, {UF_STYLER_NULL_OBJECT, UF_STYLER_NO_CB, 0, 0 } }; , UF_STYLER_ACTIVATE_CB , 1, , UF_STYLER_ACTIVATE_CB , 1,
static UF_MB_styler_actions_t actions[] = { { "TXTACC.dlg", { NULL, }; extern void ufsta (char *param, int *retcode, int rlen) { int error_code; NULL, NULL, NULL, TXTACC_cbs, UF_MB_STYLER_IS_NOT_TOP }, 0 } /* This is a NULL terminated list */
if ( (UF_initialize()) != 0) return; if ( (error_code = UF_MB_add_styler_actions ( actions ) ) != 0 ) { char fail_message[133]; UF_get_fail_message(error_code, fail_message); printf ( "%sn", fail_message ); } UF_terminate(); return; } int TXTACC_action_2_act_cb ( int dialog_id, void * client_data, UF_STYLER_item_value_type_p_t callback_data) { int ftype =79; //txtfile type int ioChannelNum =-1; int omode =0; //Read or Write mode int status = 0; /* Make sure User Function is available. */ if ( UF_initialize() != 0) return ( UF_UI_CB_CONTINUE_DIALOG ); /* 打开文件对话框*/ char prompt_string[]="保存文件"; char title_string[]="保存文件对话框"; char filter_string[]="f:\ug\chapter3_1\application\*.txt"; //default filepath char default_name[]="txtfile.txt"; char filename[UF_CFI_MAX_PATH_NAME_SIZE]=""; int response; if ( (UF_initialize()) != 0) return(UF_MB_CB_CONTINUE); UF_UI_create_filebox ( prompt_string,
title_string, filter_string, default_name, filename, &response ); char partinfo[UF_CFI_MAX_PATH_NAME_SIZE]; if (response==UF_UI_OK) //response=2 { sprintf(partinfo,"文本信息保存至文件：%sn",filename); uc1601(partinfo,1); if ( UF_CFI_ask_file_exist(filename, &status) == 0 && status == 0 ) //The file does exist { omode=3; uc1601("文件已存在，内容将被覆盖。",1); } else omode=2; ioChannelNum = uc4504(filename,omode,ftype); if (ioChannelNum >= 0 ) //Open success { /* 读取文本框内容信息*/ char buf[1024]; int nLen=0; UF_STYLER_item_value_type_t data; data.item_attr = UF_STYLER_VALUE; data.item_id = TXTACC_MTXT_0; UF_STYLER_ask_value(dialog_id,&data); nLen = data.count; char* (*strArr) = (char**)malloc((nLen) * sizeof(char*)); sprintf(buf,"Mulit_string :n"); for (int i=0;i<nLen;i++) { strArr[i] = (char*)malloc( (strlen(data.value.strings[i]) + 1) * sizeof(char)); strcpy(strArr[i], data.value.strings[i]); sprintf(buf,"%sn",strArr[i]); //写入文本文件 uc4524 (ioChannelNum,buf); } if (strArr!=NULL){ for(int j=0; j<nLen; j ++ ) { if (strArr[j] != NULL) { free(strArr[j]);
} } free(strArr); } UF_STYLER_free_value(&data); uc4540(ioChannelNum, 0 ); //To close the opened file. } else { uc1601("打开文件不成功",1); } } else //response=3 uc1601("选择文件失败。",1); UF_terminate (); return (UF_UI_CB_CONTINUE_DIALOG); } int TXTACC_action_3_act_cb ( int dialog_id, void * client_data, UF_STYLER_item_value_type_p_t callback_data) { int nLineLen = 256 + 1; char* fileSpec; int ftype = 79; int ioChannelNum =-1; int omode = 1; //Read mode char readBuf[MAX_LINE_LEN]; int fileLen = 0; int status = 0; int readLen = 0; long lResult = 0; /* Make sure User Function is available. */ if ( UF_initialize() != 0) return ( UF_UI_CB_CONTINUE_DIALOG ); /* 打开文件对话框*/ char prompt_string[]="打开文本文件"; char title_string[]="打开文件对话框"; char filter_string[]="f:\ug\chapter3_1\application\*.txt"; //default filepath char default_name[]="txtfile.txt"; char filename[UF_CFI_MAX_PATH_NAME_SIZE]=""; int response; if ( (UF_initialize()) != 0) return(UF_MB_CB_CONTINUE);
UF_UI_create_filebox (prompt_string, title_string, filter_string, default_name, filename, &response ); char partinfo[UF_CFI_MAX_PATH_NAME_SIZE]; if (response==UF_UI_OK) //response=2 { if ( UF_CFI_ask_file_exist(filename, &status) == 0 && status == 0 ) //The file does exist { //读取文件，写入信息窗口 ioChannelNum = uc4504(filename,omode,ftype); if (ioChannelNum >= 0 ) //Open success { /* 读取文本框内容信息*/ uc4547( ioChannelNum, 1, &fileLen ); //To get the file length of the file. UF_UI_open_listing_window(); readLen = uc4514(ioChannelNum, readBuf); //To read a line while (readLen>=0) { strcat(readBuf,"n"); UF_UI_write_listing_window(readBuf); readLen = uc4514(ioChannelNum, readBuf); } uc4540(ioChannelNum, 0 ); //To close the opened file. } else { uc1601("文件打开失败。",1); } } else uc1601("文件不存在在。",1); } else //response=3 uc1601("选择文件失败。",1); UF_terminate (); return (UF_UI_CB_CONTINUE_DIALOG); } of the file
三、实验要求
1、 写出程序，并调试程序，要给出测试数据和实验结果。 2、 整理上机步骤，总结经验和体会。 3、 完成实验报告和上交程序。
实验四
一、实验目的
零件设计
1、掌握利用 API 函数创建各类特征与 UG 交互环境下创建的区别和联系； 2、了解创建体素特征、扫描特征、参考特征的 API 函数； 3、掌握二次开发过程，API 函数的输入与输出参数中，特征、对象和体的 概念与关系。
二、实验内容
1、通过一个选择菜单，让用户选择创建不同的基本体素特征。
#include <stdlib.h> #include <uf.h> #include <uf_modl.h> #include <uf_part.h> #include <uf_ui.h> #include <uf_view.h> extern void ufusr( char * param, int * retcod, int param_len ) { /* 对话框设置 */ char *cp1 = "请选择"; int ip2 = 0; char cp3[4][38] = { "创建一个块(Block)", "创建一个圆柱(Cylinder)", "创建一个圆锥(Cone)", "创建一个球体(Sphere)" }; int ip4 = 4; int value; tag_t view_tag = NULL_TAG; UF_FEATURE_SIGN sign = UF_NULLSIGN; /* Block的变量声明区 */ double char tag_t blk_corner[ 3 ] = { 0.0, 0.0, 0.0 }; *blk_edge_len[ 3 ] = { "10.0", "20.0", "30.0" }; blk_obj_id;
/* Cylinder的变量声明区 */ double cyl_origin[ 3 ] = { 0.0, 0.0, 0.0 }; char *cyl_height = "20.0"; char *cyl_diam = "10.0";
double cyl_direction[ 3 ] = { 0.0, 0.0, 1.0 }; tag_t cyl_obj_id; /* Cone的变量声明区 */ double cone_origin[ 3 ] = { 0.0, 0.0, 0.0 }; char *cone_height = "20.0"; char *cone_diam[ 2 ] = { "30.0", "20.0" }; double cone_direction[ 3 ] = { 0.0, 0.0, 1.0 }; tag_t cone_obj_id; /* Sphere的变量声明区 */ double sphere_center[ 3 ] = { 0.0, 0.0, 0.0 }; char *sphere_diam = "30.0"; tag_t sphere_obj_id; if ( !UF_initialize() ) { /* 显示菜单 */ value = uc1603( cp1, ip2, cp3, ip4 ); switch( value ) { case 5: /* 创建Block(块) */ blk_edge_len, &blk_obj_id ); break; case 6: /* 创建Cylinder(圆柱) */ sign, cyl_origin, cyl_height, cyl_diam, cyl_direction, &cyl_obj_id ); break; case 7: /* 创建Cone(圆锥) */ cone_diam, cone_direction, &cone_obj_id ); break; case 8: /* 创建Sphere(球体) */ sphere_diam, &sphere_obj_id ); break; default: uc1601( "发生了错误！", 0 ); UF_MODL_create_sphere1( sign, sphere_center, UF_MODL_create_cone1( sign, cone_origin, cone_height, UF_MODL_create_cyl1( UF_MODL_create_block1( sign, blk_corner,
} /* 调整视图到合适的大小 */ UF_VIEW_ask_work_view( &view_tag ); UF_VIEW_fit_view( view_tag, 0.7 ); /* 保存文件 */ UF_PART_save( ); UF_terminate( ); } }
在编译连接后，新建或打开一个部件文件。通过 File→Execute→User Function 调用生成的动态链接库（*.dll）文件。此时界面弹出一个创建基本体 素的对话框，如图 4-1 所示，用户可以选择一个基本体素的类型，即可创建需要 的实体模型，如果如图 4-2 所示。
图 4-1 基本体素选择对话框
图 4-2 创建基本体素
2、通过定义四条直线作为拉伸体的截面线串，使用函数
UF_MODL_create_extruded（） 。
例 6-2 创建拉伸体
#include <stdlib.h> #include <uf.h> #include <uf_view.h> #include <uf_part.h> #include <uf_modl.h> void ufusr(char *param, int *retcode, int paramLen) { int i; tag_t view_tag = NULL_TAG; /* 定义四根线,作为扫描的截面线串 */ UF_CURVE_line_t sline1, sline2, sline3, sline4; tag_t line1, line2, line3, line4; tag_t generators[4]; /* 定义拉伸特征参数 */ uf_list_p_t objects; char *taper_angle = "0.0"; char *limit[ 2 ] = { "2.0", "5.0" }; double point[ 3 ] = { 0.0, 0.0, 0.0 }; double direction[ 3 ] = { 0.0, 0.0, 1.0 }; UF_FEATURE_SIGN sign = UF_NULLSIGN; uf_list_p_t features; if (!UF_initialize()) { /* 创建线#1 */ sline1.start_point[0] = 0.0; sline1.start_point[1] = 0.0; sline1.start_point[2] = 0.0; sline1.end_point[0] = 0.0; sline1.end_point[1] = 1.0; sline1.end_point[2] = 0.0; UF_CURVE_create_line(&sline1,&line1); /* 创建线#2 */ sline2.start_point[0] = 0.0; sline2.start_point[1] = 1.0; sline2.start_point[2] = 0.0; sline2.end_point[0] = 2.5; sline2.end_point[1] = 3.5;
sline2.end_point[2] = 0.0; UF_CURVE_create_line(&sline2,&line2); /* 创建线#3 */ sline3.start_point[0] = 2.5; sline3.start_point[1] = 3.5; sline3.start_point[2] = 0.0; sline3.end_point[0] = 1.0; sline3.end_point[1] = 0.0; sline3.end_point[2] = 0.0; UF_CURVE_create_line(&sline3,&line3); /* 创建线#4 */ sline4.start_point[0] = 1.0; sline4.start_point[1] = 0.0; sline4.start_point[2] = 0.0; sline4.end_point[0] = 0.0; sline4.end_point[1] = 0.0; sline4.end_point[2] = 0.0; UF_CURVE_create_line(&sline4,&line4); /* 把四根线的tag放入数组 */ generators[0] = line1; generators[1] = line2; generators[2] = line3; generators[3] = line4; /* 拉伸(extruded) */ /* 创建一个链表，以存放扫描的截面线串 */ UF_MODL_create_list( &objects ); for ( i = 0; i < 4; i++ ) { UF_MODL_put_list_item( objects, generators[ i ] ); } UF_MODL_create_extruded( objects, taper_angle, limit, point, direction, sign, &features ); UF_MODL_delete_list( &objects ); /* 调整视图到合适的大小 */ UF_VIEW_ask_work_view( &view_tag ); UF_VIEW_fit_view( view_tag, 0.7 ); /* 保存部件文件 */ UF_PART_save( ); UF_terminate(); }
}
在编译连接后，新建或打开一个部件文件。通过 File→Execute→User Function 调用生成的动态链接库文件。运行结果如图 4-3 所示。
3、在圆柱表面上打通孔，由于孔特征属于成型特征，需要有一个平的安置 面，因此可以先创建一个基准面，以基准面作为孔特征的安置面。
#include <stdlib.h> #include <uf.h> #include <uf_part.h> #include <uf_modl.h> #include <uf_view.h> #include <uf_layer.h> #include <uf_obj.h> extern void ufusr( char * param, int * retcod, int param_len ) { if (!UF_initialize()) { tag_t view_tag = NULL_TAG; /* 创建圆柱的变量声明区 */ double cyl_origin[ 3 ] = { 0.0, 0.0, 0.0 }; char *cyl_height = "20.0"; char *cyl_diam = "10.0"; double cyl_direction[ 3 ] = { 0.0, 0.0, 1.0 }; tag_t cyl_obj_id; uf_list_p_t face_list; /* 保存Cylinder面的链表 */
/* 创建相对参考平面的变量声明区 */ int num_refs = 1; tag_t object_tags[ 3 ]; tag_t object_tags1[ 3 ]; int point_select[ 3 ] = { 0, 1, 0 }; int which_plane = 1; char *offset_string = "5.0"; int num_dplanes; tag_t dplane_tag[ 2 ]; tag_t dplane_tag1[ 2 ]; int layer_fea_nu; tag_t *layer_fea_id; /* 创建孔特征的变量声明区 */ double location[ 3 ] = { 5.0, 0.0, 10.0 }; double direction[ 3 ] = { -1.0, 0.0, 0.0 }; char *diame = "5.0"; char *depth = "20.0"; char *angle = "0.0"; tag_t face_li; tag_t face_t1; /* 放置平面 */ /* 穿透平面 */
tag_t hole_obj_id; /* 创建圆柱体 */ UF_MODL_create_cyl1( UF_NULLSIGN, cyl_origin, cyl_height, cyl_diam, cyl_direction, &cyl_obj_id ); /* 获取圆满柱体所有的面，存入链表 */ UF_MODL_ask_feat_faces( cyl_obj_id, &face_list ); UF_MODL_ask_list_item( face_list, 2, &object_tags[ 0 ] ); UF_MODL_delete_list( &face_list ); /* 设置61层为工作层，将以下创建的参考平面放到61层 */ UF_LAYER_set_status( 61, UF_LAYER_WORK_LAYER ); /* 创建参考平面 */ UF_MODL_create_relative_dplane( num_refs, object_tags, point_select, which_plane, NULL, NULL, "0.0", /* 获取参考平面的Object Tag */ object_tags1[0] = dplane_tag[0]; UF_MODL_ask_feat_object( dplane_tag[0], &layer_fea_nu, &layer_fea_id ); UF_OBJ_set_blank_status( layer_fea_id[0] , UF_OBJ_BLANKED); UF_free( layer_fea_id ); /* 由第一个参考平面偏置出第二个参考平面，使第二个参考平面与圆满柱平面相切 */ UF_MODL_create_relative_dplane( 1, object_tags1, point_select, which_plane, &num_dplanes, dplane_tag );
NULL, NULL, offset_string, &num_dplanes, dplane_tag1 ); /* 设置层1为工作层 */ UF_LAYER_set_status( 1, UF_LAYER_WORK_LAYER ); /* 创建孔特征 */ face_li = dplane_tag1[ 0 ]; /* 放置面为参考平面 */ face_t1 = object_tags[ 0 ]; /* 穿透面为圆柱平面 */ UF_MODL_create_simple_hole( location, direction, diame, depth, angle, face_li, face_t1, &hole_obj_id ); /* 调整视图到合适的大小 */ UF_VIEW_ask_work_view( &view_tag ); UF_VIEW_fit_view( view_tag, 0.7 ); /* 保存部件 */ UF_PART_save( ); UF_terminate( ); } }
在编译连接后，新建或打开一个部件文件。通过 File→Execute→User Function 调用生成的动态链接库文件。运行结果如图 4-4 所示。
三、实验要求
1、写出程序，并调试程序，要给出测试数据和实验结果。 2、整理上机步骤，总结经验和体会。 3、完成实验报告和上交程序。
实验五
一、实验目的
工程图设计
1、 掌握 API 函数创建工程图的过程和办法； 2、 掌握图框模板文件的导入、工程图的创建和管理、建立和编辑视图等。 3、 了解辅助文本、尺寸的创建和创建坐标系、视图与控制布局等；
二、实验内容
1、工程图参数设置选择。
#include <stdio.h> #include <string.h> #include <uf.h> #include <uf_drf.h> #include <uf_obj.h> #include <uf_ui.h> #include <uf_part.h> #include <uf_object_types.h> #include <uf_draw.h> #include <uf_modl.h> /* 设置尺寸参数 */ void set_dimension_parameters( void ) { /* 设置变量定义 */ char message[133]; int double char mpi_array[100]; mpr_array[70]; rad_symbol[27], dia_symbol[27];
UF_UI_open_listing_window(); UF_UI_write_listing_window( "n设置前的系统工程图参数：nn" ); /* 查询设置前的系统制图参数 */ UF_DRF_ask_preferences(mpi_array, mpr_array, rad_symbol, dia_symbol ); sprintf( message,"尺寸值的小数位数:mpi[3] = %dn公差值的小数位数: mpi[4] = %dn", mpi_array[3], mpi_array[4] ); UF_UI_write_listing_window(message); sprintf( message,"公差类型:mpi[6] = %dn上公差:mpr[24] = %fn下公差: mpr[25] = %fn", mpi_array[6], mpr_array[24], mpr_array[25] ); UF_UI_write_listing_window(message);
/* 设置尺寸、公差等制图参数 */ mpi_array[3] = 2; /* 设置尺寸值的小数位 */ mpi_array[4] = 4; /* 设置公差值小数位 */ mpi_array[6] = 4; /* 设置公差类型（单线双向类） */ mpr_array[24] = 0.00002; mpr_array[25] = 0.00002; /* 设置上公差 */ /* 设置下公差 */
UF_DRF_set_preferences( mpi_array, mpr_array, rad_symbol, dia_symbol ); UF_UI_write_listing_window( "nn设置后的系统工程图参数：nn" ); /* 查询设置后的系统制图参数 */ UF_DRF_ask_preferences(mpi_array, mpr_array, rad_symbol, dia_symbol ); sprintf( message,"尺寸值的小数位数:mpi[3] = %dn公差值的小数位数: mpi[4] = %dn", mpi_array[3], mpi_array[4] ); UF_UI_write_listing_window(message); sprintf( message,"公差类型:mpi[6] = %dn上公差:mpr[24] = %fn下公差: mpr[25] = %fn", mpi_array[6], mpr_array[24], mpr_array[25] ); UF_UI_write_listing_window(message); } /* 设置视图比例 */ void set_view_scale( void ) { int logical tag_t tag_p_t tag_t num_views = 0; auto_update; drawing_tag = NULL_TAG; view_list = NULL; exp_tag = NULL_TAG;
/* 查询当前图纸标识 */ UF_DRAW_ask_current_drawing( &drawing_tag ); /* 获得当前图纸的视图个数及标识 */ UF_DRAW_ask_views( drawing_tag, &num_views, &view_list ); /* 设置视图自动更新 */ auto_update = true; if ( num_views > 0 ) UF_DRAW_set_auto_update (view_list[0], &auto_update); /* 设置视图比例 */ UF_MODL_create_exp_tag ("1.5", &exp_tag); UF_DRAW_set_view_parm_scale (view_list[0], exp_tag); UF_free( view_list ); } extern void ufusr( char * param, int * retcod, int param_len ) { if(!UF_initialize()) {
/* 对话框设置参数 */ char *cp1 = "设置制图参数"; int int int ip2 = 0; ip4 = 2; value; char cp3[2][38] = { "设置尺寸参数", "设置视图比例" };
value = uc1603( cp1, ip2, cp3, ip4 ); switch( value ) { case 5: break; case 6: break; default: uc1601( "发生了错误！", 0 ); } UF_terminate(); } } /* 设置视图比例 */ set_view_scale( ); /* 设置尺寸参数 */ set_dimension_parameters( );
在编译连接后，通过 File→Execute→User Function 调用生成的动态链接 库文件。此时界面弹出一个用户选择对话框，如图 5-1 所示。当用户选择“设置 尺寸参数”选项后，新建的尺寸标注将加上公差标注，尺寸保留两位小数，并且 弹出一个消息对话框，列出参数设置前后的值，结果如图 5-2、5-3 所示。当用 户选择“设置视图比例”选项后，当前图纸上的视图将放大 1.5 倍。
图 5-1 工程图参数设置选择对话框
图 5-2 尺寸参数设置消息框
( a ) 参数设置前 图 5-3 尺寸参数设置效果比较
( b )参数设置后
2、查询工程图纸参数
#include <stdio.h> #include <uf.h> #include <uf_defs.h> #include <uf_draw.h>
#include <uf_ui.h> extern void ufusr( char *param, int *retcode, int param_len) { if(!UF_initialize()) { int char num_drawings; message[MAX_LINE_SIZE + 1];
/* 创建第一张图纸的变量定义 */ tag_t char fdrawing_tag = NULL_TAG; fdrawing_name[MAX_ENTITY_NAME_SIZE] = "first_drawing";
UF_DRAW_info_t fdrawing_info; /* 创建第二张图纸的变量定义 */ tag_t char sdrawing_tag = NULL_TAG; sdrawing_name[MAX_ENTITY_NAME_SIZE] = "second_drawing";
UF_DRAW_info_t sdrawing_info; /* 设置图纸的参数 */ fdrawing_info.drawing_scale = 1.0; fdrawing_info.projection_angle = UF_DRAW_THIRD_ANGLE_PROJECTION; fdrawing_info.size.metric_size_code = UF_DRAW_A1; fdrawing_info.size_state = UF_DRAW_METRIC_SIZE; fdrawing_info.units = UF_PART_METRIC; /* 创建第一张图纸 */ UF_DRAW_create_drawing( fdrawing_name, &fdrawing_info, &fdrawing_tag); /* 获得第一张图纸的参数 */ UF_DRAW_ask_drawing_info( fdrawing_tag, &sdrawing_info ); /* 在第一张图纸参数的基础上创建第二张图纸 */ sdrawing_info.drawing_scale = 2.0; sdrawing_info.size.metric_size_code = UF_DRAW_A3; UF_DRAW_create_drawing( sdrawing_name, &sdrawing_info, &sdrawing_tag); /* 为第一张图纸更名 */ UF_DRAW_rename_drawing( fdrawing_tag, "my_first_drawing" ); UF_DRAW_open_drawing( fdrawing_tag ); /* 获得当前部件文件中图纸的数量，并输出到消息框中 */ UF_DRAW_ask_num_drawings( &num_drawings ); UF_UI_open_listing_window(); sprintf(message,"当前部件文件共有： %d 张图纸。", num_drawings ); UF_UI_write_listing_window(message); UF_terminate(); } }
编译连接后，通过 File→Execute→User Function 调用生成的动态链接库
文件。结果将在部件导航器中创建两张图纸，分别名为：second_drawing 和 my_first_drawing，如图 5-4 所示。同时弹出一个消息对话框，显示当前部件中 图纸的数量，如图 5-5 所示。
图 5-4 创新工程图
图 5-5 查询工程图参数消息框
3、创建视图
#include <stdio.h> #include <uf.h> #include <uf_part.h> #include <uf_drf.h> #include <uf_draw.h> #include <uf_obj.h> #include <uf_ui.h> void ufusr (char *param, int *retcode, int paramLen) { if (!UF_initialize()) { int char num_views; message[MAX_LINE_SIZE + 1];
/* 定义图纸变量 */ char drawing_name[MAX_ENTITY_NAME_SIZE] = "my_drawing"; UF_DRAW_info_t drawing_info; tag_t tag_t tag_t drawing_tag = NULL_TAG; view_tag = NULL_TAG; front_view_tag = NULL_TAG;
/* 定义前视图变量 */
char double tag_t char double
*front_view_name = "FRONT"; front_reference_point[2] = {210.0, 400.0}; tri_view_tag = NULL_TAG; *tri_view_name = "TFR-TRI"; tri_reference_point[2] = {630.0, 120.0};
/* 定义轴测视图变量 */
/* 定义俯视图变量 */ UF_DRAW_proj_dir_t bottom_projection_direction = UF_DRAW_project_below; double tag_t bottom_reference_point[2] = {210.0, 120.0}; bottom_view_tag = NULL_TAG;
/* 定义左视图变量 */ UF_DRAW_proj_dir_t left_projection_direction = UF_DRAW_project_left; double tag_t left_reference_point[2] = {630.0, 400.0}; left_view_tag = NULL_TAG;
/* 创建并打开图纸 */ drawing_info.drawing_scale = 1.0; drawing_info.projection_angle = UF_DRAW_THIRD_ANGLE_PROJECTION; drawing_info.size.metric_size_code = UF_DRAW_A1; drawing_info.size_state = UF_DRAW_METRIC_SIZE; drawing_info.units = UF_PART_METRIC; UF_DRAW_create_drawing( drawing_name, &drawing_info,&drawing_tag); UF_DRAW_open_drawing( drawing_tag ); /* 设置视图参数 */ UF_DRAW_view_info_t view_info; UF_DRAW_initialize_view_info( &view_info ); view_info.view_status = UF_DRAW_ACTIVE_VIEW; view_info.anchor_point = NULL_TAG; view_info.view_scale = 1.0; view_info.use_ref_pt = TRUE; view_info.inherit_boundary = TRUE; /* 创建前视图 */ UF_OBJ_cycle_by_name( front_view_name, &view_tag ); if( view_tag != NULL_TAG ) { UF_DRAW_import_view( drawing_tag, view_tag, front_reference_point, &view_info, &front_view_tag ); UF_DRAW_define_view_auto_rect( front_view_tag ); } view_tag = NULL_TAG; /* 创建轴测视图 */ UF_OBJ_cycle_by_name( tri_view_name, &view_tag ); if( view_tag != NULL_TAG ) { UF_DRAW_import_view( drawing_tag, view_tag, tri_reference_point,
&view_info, &tri_view_tag ); UF_DRAW_define_view_auto_rect( tri_view_tag ); } /* 创建俯视图 */ if( front_view_tag { UF_DRAW_add_orthographic_view( drawing_tag, front_view_tag, bottom_projection_direction, bottom_reference_point, &bottom_view_tag ); UF_DRAW_define_view_auto_rect( bottom_view_tag ); } /* 创建左视图 */ if( front_view_tag { UF_DRAW_add_orthographic_view( drawing_tag, front_view_tag, left_projection_direction, left_reference_point, &left_view_tag ); UF_DRAW_define_view_auto_rect( left_view_tag ); } /*查询当前图纸的视图个数 */ UF_DRAW_ask_num_views( NULL_TAG, &num_views ); UF_UI_open_listing_window(); sprintf(message,"当前图纸共有： %d 个视图。", num_views ); UF_UI_write_listing_window( message ); UF_terminate(); } } != NULL_TAG ) != NULL_TAG )
编译连接后，通过 File→Execute→User Function 调用生成的动态链接库 文件。结果将在部件导航器中创建并打开名为“my_drawing”的图纸，在图纸上 创建当前部件的前视图、左视图、俯视图和轴测图，结果如图 5-6 所示。同时弹 出一个消息对话框，显示当前图纸中视图的数量，如图 5-7 所示。
图 5-6 创建视图
4、创建尺寸和辅助文本
#include <stdio.h> #include <uf.h> #include <uf_ui.h> #include <uf_drf.h> #include <uf_part.h> #include <uf_modl.h> #include <uf_draw.h> #include <uf_draw_types.h> #include <uf_obj.h> #include <uf_layout.h> #include <uf_view.h> extern void ufusr( char* param, int* retcod, int param_len ) { if ( !UF_initialize( ) ) { /* 创建圆柱 */ double cyl_origin[ 3 ] = { 0.0, 0.0, 0.0 }; double cyl_direction[ 3 ] = { 0.0, 0.0, 1.0 }; tag_t tag_cyl; UF_MODL_create_cyl1( UF_NULLSIGN, cyl_origin, "cyl_height=6", "cyl_diameter=4", cyl_direction, &tag_cyl ); /* 预设置工程图参数 */ char radsym[7], diasym[7]; int mpi[100]; double mpr[70]; UF_DRF_ask_preferences( mpi, mpr, radsym, diasym ); mpi[3] = 2; /* 小数点的位数保留两位 */ /* 设置尺寸文本的高度 */ /* 设置附加文本的高度 */ mpr[32] = 0.5; mpr[44] = 0.3;
UF_DRF_set_preferences( mpi, mpr, radsym, diasym ); /* 创建一张图纸 */ tag_t drawing_tag; UF_DRAW_info_t drawing_info; drawing_info.size_state = UF_DRAW_METRIC_SIZE; drawing_info.size.metric_size_code = UF_DRAW_A2; drawing_info.drawing_scale = 1.0; drawing_info.units = UF_PART_METRIC; drawing_info.projection_angle = UF_DRAW_THIRD_ANGLE_PROJECTION; UF_DRAW_create_drawing( "my_drawing", &drawing_info, &drawing_tag ); UF_DRAW_open_drawing( drawing_tag ); /* 创建前视图 */ tag_t view_tag = NULL;
UF_OBJ_cycle_by_name( "FRONT", &view_tag ); double reference_point[ 2 ] = { 80.0, 200.0 }; UF_DRAW_view_info_t view_info; UF_DRAW_initialize_view_info( &view_info ); view_info.view_status = UF_DRAW_ACTIVE_VIEW; view_info.anchor_point = NULL_TAG; view_info.view_scale = 1.0; view_info.use_ref_pt = TRUE; view_info.inherit_boundary = FALSE; tag_t front_view_tag; UF_DRAW_import_view( drawing_tag, view_tag, reference_point, &view_info, &front_view_tag ); UF_DRAW_define_view_auto_rect( front_view_tag ); /* 创建俯视图 */ tag_t bottom_view_tag; reference_point[ 0 ] = 80.0; reference_point[ 1 ] = 100.0; UF_DRAW_add_orthographic_view( drawing_tag, front_view_tag, UF_DRAW_project_below, reference_point, &bottom_view_tag ); UF_DRAW_define_view_auto_rect( bottom_view_tag ); tag_t cyl_face_tag=NULL_TAG; uf_list_p_t cyl_face_list; UF_MODL_ask_feat_faces( tag_cyl, &cyl_face_list ); UF_MODL_ask_list_item( cyl_face_list, 2, &cyl_face_tag ); UF_MODL_delete_list( &cyl_face_list ); /* 在前视图上标注圆柱的高 */ tag_t object=NULL_TAG, front_objects[6]; int subtype, type, count=0; UF_VIEW_cycle_objects( front_view_tag, UF_VIEW_VISIBLE_OBJECTS, &object ); while(object!=NULL_TAG) { UF_OBJ_ask_type_and_subtype (object,&type, &subtype ); if(type==UF_solid_type && subtype==UF_solid_edge_subtype ) { front_objects[count] = object; count++; } UF_VIEW_cycle_objects( front_view_tag, UF_VIEW_VISIBLE_OBJECTS, &object ); } UF_DRF_object_t object1; UF_DRF_object_t object2; UF_DRF_init_object_structure( &object1 ); UF_DRF_init_object_structure( &object2 ); object1.object_tag = front_objects[ 0 ];
object1.object_assoc_type = UF_DRF_end_point; object1.object_assoc_modifier = UF_DRF_first_end_point; object1.object_view_tag = front_view_tag; object2.object_tag = front_objects[ 1 ]; object2.object_assoc_type = UF_DRF_end_point; object2.object_assoc_modifier = UF_DRF_first_end_point; object2.object_view_tag = front_view_tag; UF_DRF_text_t dim_text; dim_text.lines_app_text = 0; dim_text.appended_text = NULL; dim_text.user_dim_text = NULL; double dimension_3d_origin[ 3 ] = { 8.0, 11.0, 0.0 }; tag_t dimension_tag=NULL_TAG; UF_DRF_create_vertical_dim( &object1, &object2, &dim_text, dimension_3d_origin, &dimension_tag ); /* 为圆柱底面创建标签 */ char text[1][132+1]; tag_t text_aid_tag; strcpy(text[0], "bottom face of cylinder"); double origin[3] = {6.0, 7.0, 0.0}; double base_pt[3] = {6.0, 7.0, 0.0}; UF_DRF_create_label( 1, text, origin, UF_DRF_leader_attach_object, &object2, base_pt, &text_aid_tag); /* 在俯视图上标注圆柱的直径 */ UF_DRF_object_t object3; UF_DRF_init_object_structure( &object3 ); UF_VIEW_cycle_objects( bottom_view_tag, UF_VIEW_VISIBLE_OBJECTS, &object ); while(object!=NULL_TAG) { UF_OBJ_ask_type_and_subtype (object,&type, &subtype ); if(type==UF_solid_type && subtype==UF_solid_edge_subtype ) { object3.object_tag = object; break; } UF_VIEW_cycle_objects( bottom_view_tag, UF_VIEW_VISIBLE_OBJECTS, &object ); } object3.object_view_tag = bottom_view_tag; object3.object_assoc_type = UF_DRF_arc_center; dimension_3d_origin[ 0 ] = 8.0; dimension_3d_origin[ 1 ] = 2.0; UF_DRF_create_diameter_dim( &object3, &dim_text,dimension_3d_origin, &dimension_tag ); /* 在图纸上创建一个注释 */
int num_lines_text; char* text_string[2]; double origin_3d[3]; int orientation; tag_t note_tag=NULL; num_lines_text=2; text_string[0]="This is a note!"; text_string[1]="mark dimension for cylinder!"; origin_3d[0]=6.0; origin_3d[1]=15.0; origin_3d[2]=0.0; orientation=0; UF_DRF_create_note(num_lines_text,text_string,origin_3d,orientation,¬e_tag); /* 更新图纸上所有的视图 */ UF_DRAW_upd_out_of_date_views( drawing_tag ); UF_terminate( ); } }
编译连接后，通过 File→Execute→User Function 调用生成的动态链接库 文件。结果如图 5-8 所示。
图 5-8 创建尺寸和辅助文本
三、实验要求
1、 写出程序，并调试程序，要给出测试数据和实验结果。 2、 整理上机步骤，总结经验和体会。 3、 完成实验报告和上交程序。
实验六
一．实验目的
装配设计
1、 掌握二次开发过程中，关于装配的基本概念和术语； 2、 理解装配树的结构，掌握如何遍历装配对和部件对象间的访问； 3、 了解配合关系的创建与编辑，引用集的操作及装配复制操作等。
二．实验内容
1、装入部件 通过函数 UF_ASSEM_add_part_to_assembly()指定部件装入的位置 、姿态 等信息，实现在装配体中装入一个部件功能； 2、创建配合关系 a．通过函数 UF_ASSEM_init_mc()初始化约束； b．定义约束关系，即填写结构 UF_ASSEM_constraint_s 中信息； 装配中各部件间的配合关系是通过装配约束关系来实现的。 装配约束是指一 个部件到另一个部件的约束，将部件 A 配合到部件 B 上，则部件 A 称为主动件 (from)，部件 B 称为被动件(to)，在约束求解过程中，被动件在装配空间中的位 置固定， 而主动件将变换姿态到满足装配约束位置上。组成配合关系的约束之间 不能存在几何关系上的矛盾，也不能形成循环定义。 c．通过函数 UF_ASSEM_solve_mc()求解约束； d．通过函数 UF_ASSEM_apply_mc_data 将约束应用到装配体上； e．通过函数 UF_MODL_update 更新模型。
#include <stdio.h> #include <uf.h> #include <uf_ui.h> #include <uf_obj.h> #include <uf_disp.h> #include <uf_modl.h> #include <uf_part.h> #include <uf_assem.h> #define UF_CALL( X ) ( report( __FILE__, __LINE__, #X, ( X ) ) ) int report( char *file, int line, char *call, int irc ); void DoAssembly( void ); int report( char *file, int line, char *call, int irc ) {
if ( irc ) { char err_msg[ UF_UI_MAX_STRING_LEN + 1 ]; char msg[ 133 ]; char fail_message[ 133 ]; int len;
UF_get_fail_message( irc, fail_message ); sprintf( err_msg, "%s, line %d: error %d: %s", file, line, irc, fail_message ); len = strlen( err_msg ); len = ( len < 131 ) ? len : 131; strncpy ( msg, err_msg, len ); msg[ len + 1 ] = ' 00'; uc1601( err_msg, TRUE ); } return( irc ); } extern DllExport void ufusr( char *parm, int *returnCode, int rlen ) { if ( UF_initialize() ) return; DoAssembly(); UF_terminate(); } void DoAssembly( void ) { if ( NULL_TAG == UF_PART_ask_display_part() ) { uc1601( "请新建一个文件再进行本操作！", 1 ); return; } tag_t tagInsCyl = NULL_TAG; tag_t tagInsVBlk= NULL_TAG; tag_t tagOccCyl = NULL_TAG; tag_t tagOccVBlk= NULL_TAG; UF_PART_load_status_t ErrorStatus; double dblzOrigin[ 3 ] = { 0, 0, 0 }; double dblzCsysMatrix[ 6 ] = { 1, 0, 0, 0, 1, 0 }; /* 装入部件 GB2208_80_Vblock.prt */ UF_ASSEM_add_part_to_assembly( UF_PART_ask_display_part(), "f:\ug\chapter4_1\GB2208_80_Vblock.prt",
NULL, "VBLOCK", dblzOrigin, dblzCsysMatrix, -1, &tagInsVBlk, &ErrorStatus ); /* 装入部件 Cylinder.prt */ dblzOrigin[ 1 ] = 50; UF_ASSEM_add_part_to_assembly( UF_PART_ask_display_part(), "f:\ug\chapter4_1\Cylinder.prt", NULL, "CYLINDER", dblzOrigin, dblzCsysMatrix, -1, &tagInsCyl, &ErrorStatus ); tagOccCyl = UF_ASSEM_ask_part_occ_of_inst( NULL_TAG, tagInsCyl ); tagOccVBlk= UF_ASSEM_ask_part_occ_of_inst( NULL_TAG, tagInsVBlk ); /* 创建配合关系 */ UF_ASSEM_mating_condition_t McData; tag_t tagObjectFrom tag_t tagObjectTo tag_t tagPrototypeFrom = NULL_TAG; = NULL_TAG; = NULL_TAG;
tag_t tagPrototypeTo = NULL_TAG; /* 初始化约束*/ UF_ASSEM_init_mc( &McData ); /* 定义约束，构造配合关系*/ McData.mated_object = tagInsCyl; McData.num_constraints = 3; McData.name = NULL; McData.user_name = false; McData.override = false; McData.suppressed = false; McData.implicit = false; tagObjectFrom = NULL_TAG; tagObjectTo = NULL_TAG; &tagObjectTo ); UF_OBJ_cycle_by_name( "CYL_FACE_3", &tagObjectFrom ); UF_OBJ_cycle_by_name( "P1", tagPrototypeFrom= UF_ASSEM_ask_prototype_of_occ( tagObjectFrom ); tagPrototypeTo = UF_ASSEM_ask_prototype_of_occ( tagObjectTo ); McData.constraints[ 0 ].from = tagPrototypeFrom;
McData.constraints[ 0 ].from_part_occ = tagOccCyl; McData.constraints[ 0 ].from_status McData.constraints[ 0 ].from_type McData.constraints[ 0 ].to McData.constraints[ 0 ].to_part_occ McData.constraints[ 0 ].to_status McData.constraints[ 0 ].to_type McData.constraints[ 0 ].mate_type McData.constraints[ 0 ].offset McData.constraints[ 0 ].name McData.constraints[ 0 ].user_name McData.constraints[ 0 ].inherited McData.constraints[ 0 ].suppressed UF_DISP_set_highlight( tagObjectFrom, UF_DISP_set_highlight( tagObjectTo, uc1601( "这两个面进行相切操作", 1 ); UF_DISP_set_highlight( tagObjectFrom, UF_DISP_set_highlight( tagObjectTo, 0 ); tagObjectFrom = NULL_TAG; tagObjectTo = NULL_TAG; &tagObjectTo ); UF_OBJ_cycle_by_name( "CYL_FACE_3", &tagObjectFrom ); UF_OBJ_cycle_by_name( "P2", tagPrototypeFrom= UF_ASSEM_ask_prototype_of_occ( tagObjectFrom ); tagPrototypeTo = UF_ASSEM_ask_prototype_of_occ( tagObjectTo ); McData.constraints[ 1 ].from McData.constraints[ 1 ].from_status McData.constraints[ 1 ].from_type McData.constraints[ 1 ].to McData.constraints[ 1 ].to_part_occ McData.constraints[ 1 ].to_status McData.constraints[ 1 ].to_type McData.constraints[ 1 ].mate_type McData.constraints[ 1 ].offset McData.constraints[ 1 ].name McData.constraints[ 1 ].user_name McData.constraints[ 1 ].inherited McData.constraints[ 1 ].suppressed UF_DISP_set_highlight( tagObjectFrom, UF_DISP_set_highlight( tagObjectTo, uc1601( "这两个面进行相切操作", 1 ); UF_DISP_set_highlight( tagObjectFrom, UF_DISP_set_highlight( tagObjectTo, 0 ); tagObjectFrom = NULL_TAG; tagObjectTo = NULL_TAG; 0 ); = tagPrototypeFrom; = UF_ASSEM_ok; = UF_ASSEM_cylindrical_face; = tagPrototypeTo; = tagOccVBlk; = UF_ASSEM_ok; = UF_ASSEM_planar_face; = UF_ASSEM_tangent; = NULL_TAG; = NULL; = false; = false; = false; 1 ); 1 ); McData.constraints[ 1 ].from_part_occ = tagOccCyl; 0 ); = UF_ASSEM_ok; = UF_ASSEM_cylindrical_face; = tagPrototypeTo; = tagOccVBlk; = UF_ASSEM_ok; = UF_ASSEM_planar_face; = UF_ASSEM_tangent; = NULL_TAG; = NULL; = false; = false; = false; 1 ); 1 );
McData.constraints[ 0 ].has_help_point = false;
McData.constraints[ 1 ].has_help_point = false;
UF_OBJ_cycle_by_name( "CYL_FACE_1", &tagObjectFrom ); UF_OBJ_cycle_by_name( "P3", &tagObjectTo ); tagPrototypeFrom= UF_ASSEM_ask_prototype_of_occ( tagObjectFrom ); tagPrototypeTo = UF_ASSEM_ask_prototype_of_occ( tagObjectTo ); McData.constraints[ 2 ].from McData.constraints[ 2 ].from_status McData.constraints[ 2 ].from_type McData.constraints[ 2 ].to McData.constraints[ 2 ].to_part_occ McData.constraints[ 2 ].to_status McData.constraints[ 2 ].to_type McData.constraints[ 2 ].mate_type McData.constraints[ 2 ].offset McData.constraints[ 2 ].name McData.constraints[ 2 ].user_name McData.constraints[ 2 ].inherited McData.constraints[ 2 ].suppressed UF_DISP_set_highlight( tagObjectFrom, UF_DISP_set_highlight( tagObjectTo, uc1601( "这两个面进行对齐操作", 1 ); UF_DISP_set_highlight( tagObjectFrom, UF_DISP_set_highlight( tagObjectTo, 0 ); double dblzTransform[ 4 ][ 4 ]; UF_ASSEM_dof_t Dof; UF_ASSEM_mc_status_t Status; 0 ); = tagPrototypeFrom; = UF_ASSEM_ok; = UF_ASSEM_planar_face; = tagPrototypeTo; = tagOccVBlk; = UF_ASSEM_ok; = UF_ASSEM_planar_face; = UF_ASSEM_align; = NULL_TAG; = NULL; = false; = false; = false; 1 ); 1 ); McData.constraints[ 2 ].from_part_occ = tagOccCyl;
McData.constraints[ 2 ].has_help_point = false;
/* 求解约束*/ UF_CALL( UF_ASSEM_solve_mc( &McData, &Status, &Dof, dblzTransform ) ); if ( UF_ASSEM_mc_solved == Status ) { uc1601( "求解约束成功！", 1 ); UF_ASSEM_mc_structure_state_t StructStatus; /* 将约束应用到装配体上*/ UF_CALL( UF_ASSEM_apply_mc_data( &McData, &StructStatus, &Status ) ); if ( UF_ASSEM_structure_ok == StructStatus ) { uc1601( "应用装配成功！", 1 ); /* 更新模型*/ UF_MODL_update(); UF_DISP_refresh(); } else uc1601( "应用装配失败！", 1 ); }
else uc1601( "求解约束失败！", 1 ); } }
三．实验要求
1. 2. 3. 写出程序，并调试程序，要给出测试数据和实验结果。 整理上机步骤，总结经验和体会。 完成实验报告和上交程序。
