精华内容
下载资源
问答
  • redis图形化界面

    2019-01-24 09:49:04
    这是一个redis的图形化界面,下一个我将会上传redis的服务
  • java图形化界面框架,java图形化界面框架java图形化界面框架java图形化界面框架java图形化界面框架
  • 主要介绍了配置XManager5连接Linux图形化界面详解,需要的朋友可以参考下
  • 学生管理系统,包含录入学生,删除学生,显示信息等功能,是图形化界面的版本,利用C++和 Qt的库开发。
  • 支持局域网端口扫描,图形化界面,支持从文件导入网址进行批量扫描
  • SSH Secure Shell Client是一款不错的远程linux的工具, 支持命令行方式(与Secure CRT 相同), 同时也支持图形化界面操作,如同(WinSCP), 英文版,但都是常见单词,一看就懂,实在想汉化的也自行百度汉化包!
  • zookeeper客户端 图形化界面zookeeper客户端 图形化界面zookeeper客户端 图形化界面zookeeper客户端 图形化界面zookeeper客户端 图形化界面
  • 史上最好用的redis图形化界面客户端,下不了吃亏下不了上当,学习redis的你值得拥有。
  • Java图形化界面实现图书管理系统.zip Java图形化界面实现图书管理系统.zip
  • 利用Java实现简单的图形化图书管理系统,连接数据库对数据库中的数据进行操作,文件中包括建表,插入数据的DDL语言
  • 友好的图形化界面,实现对学生成绩的各项功能(全面)
  • MFC实现,用图形化界面显示二叉树,对二叉树进行前中后序遍历以及线索化,并输出未线索化和线索化之后按前中后序遍历的结果
  • 本文借助easyx库函数(提供下载链接),很方便地用C语言实现了鼠标、按钮、进度条、坐标尺等操作,为普通C程序的友好人机交互界面提供了一种简单便捷的方案。

    0.引言

    \qquad 看了CSDN上很多关于C程序图形化界面的介绍,有的代码繁琐难解,不方便调试修改;有的不够详细。本文提供的代码简单、易于移植、容易理解,望急需使用C语言制作图形化界面的朋友采纳。
    \qquad 对easyx尚不熟悉的朋友不需要担心,我敢打包票它只需10分钟就可以上手,而它为你节省的时间可能是3个小时甚至更多。关于easyx的简单应用请参考一篇我以前写的关于C程序可视化的博文。
    →【C语言实现动画控制】←
    \qquad 本文的讲解是循序渐进的,读者应该重点关注每个步骤的理解,两步之间代码的变化,即可完全理解本文。

    1.素材准备

    1. easyx的下载链接如下:(本文使用的版本是2014冬至版)
      https://www.easyx.cn/downloads/
      注:使用easyx需要注意它兼容的编译器(下载的帮助文件会写),不同的easyx兼容的编译器不同,但总是和visual C++6兼容(和字符编码有关),本文以visual C++6编译器为例书写代码。
    2. easyx的最新英文帮助文档链接(下载2014冬至版会自带中文帮助文档):
      https://docs.easyx.cn/en-us/intro
    3. 如果你成功下载了easyx2014冬至版,那么解压后把头文件(easyx.h和graphic.h)和lib文件(amd64)分别放在VC文件夹默认的include文件夹和lib文件夹中。右键你的VC程序,选择打开文件所在位置,然后找到MFC文件夹,友情提供两个文件夹的位置截图。
      include
      lib
    4. 建议编译的C文件以cpp后缀保存。

    2.编程

    2.1.创建你的界面

    \qquad 创建一个480×360的窗口,我们需要使用initgraph()函数,闲言少叙,让我们直接看一段代码:

    #include <graphics.h>              // 引用图形库头文件
    #include <conio.h>
    #include <stdio.h>
    #include <windows.h>				//用到了定时函数sleep()
    #include <math.h>
    
    int main()
    {
    	int i;
    	short win_width,win_height;//定义窗口的宽度和高度
    	win_width = 480;win_height = 360;
    	initgraph(win_width,win_height);//初始化窗口(黑屏)
    	for(i=0;i<256;i+=5)
    	{
    		setbkcolor(RGB(i,i,i));//设置背景色,原来默认黑色
    		cleardevice();//清屏(取决于背景色)
    		Sleep(15);//延时15ms
    	}
    	closegraph();//关闭绘图界面
    }
    
    

    \qquad 这段代码很容易理解,运行这段程序,就会出现逐渐明亮的屏幕。因为不断刷新背景色为 R G B ( i , i , i ) RGB(i,i,i) RGB(i,i,i)。C语言中的颜色使用十六进制表示的,RGB函数可以将0~255范围内的三个整数三原色转换成这个十六进制。
    \qquad cleardevice()函数用于清屏,是界面内所有元素都被清空,一般只会在初始化出现。
    \qquad Sleep()是毫秒级延迟,当然界面变亮时间不一定是准确的15ms×255/5=0.765s,因为其他语句还需要执行时间。
    \qquad closegraph():关闭绘图界面。注意,如果初始化了绘图界面但没有在主函数结束前关闭它,可能会引发一些莫名其妙的错误!所以这个函数一定要有!

    2.2.创建按钮

    \qquad 我们尝试在界面创建几个按钮,按钮需要的操作是绘制矩形和打印文字。虽然看着简单,但是里面还是有点学问,为了方便大家理解,还是先放上代码和注释。

    #include <graphics.h>              // 引用图形库头文件
    #include <conio.h>
    #include <stdio.h>
    #include <windows.h>				//用到了定时函数sleep()
    #include <math.h>
    int r1[]={30,20,130,60};//输入按钮的矩形参数
    int r2[]={170,20,220,60};//运行按钮的矩形参数
    int r3[]={260,20,310,60};//退出按钮的矩形参数
    int main()
    {
    	int i;
    	short win_width,win_height;//定义窗口的宽度和高度
    	win_width = 480;win_height = 360;
    	initgraph(win_width,win_height);//初始化窗口(黑屏)
    	for(i=0;i<256;i+=5)
    	{
    		setbkcolor(RGB(i,i,i));//设置背景色,原来默认黑色
    		cleardevice();//清屏(取决于背景色)
    		Sleep(15);//延时15ms
    	}
    	RECT R1={r1[0],r1[1],r1[2],r1[3]};//矩形指针R1
    	RECT R2={r2[0],r2[1],r2[2],r2[3]};//矩形指针R2
    	RECT R3={r3[0],r3[1],r3[2],r3[3]};//矩形指针R3
    	LOGFONT f;//字体样式指针
    	gettextstyle(&f);					//获取字体样式
    	_tcscpy(f.lfFaceName,_T("宋体"));	//设置字体为宋体
    	f.lfQuality = ANTIALIASED_QUALITY;    // 设置输出效果为抗锯齿  
    	settextstyle(&f);                     // 设置字体样式
    	settextcolor(BLACK);				//BLACK在graphic.h头文件里面被定义为黑色的颜色常量
    	drawtext("输入参数",&R1,DT_CENTER | DT_VCENTER | DT_SINGLELINE);//在矩形区域R1内输入文字,水平居中,垂直居中,单行显示
    	drawtext("运行",&R2,DT_CENTER | DT_VCENTER | DT_SINGLELINE);//在矩形区域R2内输入文字,水平居中,垂直居中,单行显示
    	drawtext("退出",&R3,DT_CENTER | DT_VCENTER | DT_SINGLELINE);//在矩形区域R3内输入文字,水平居中,垂直居中,单行显示
    	setlinecolor(BLACK);
    	rectangle(r1[0],r1[1],r1[2],r1[3]);
    	rectangle(r2[0],r2[1],r2[2],r2[3]);
    	rectangle(r3[0],r3[1],r3[2],r3[3]);
    	system("pause");//暂停,为了显示
    	closegraph();
    	return 0;
    }
    

    在这里插入图片描述
    \qquad 这里需要特别介绍的是矩形指针 p R e c t pRect pRect,它使用句柄RECT定义,并且不可以中途再次赋值。之所以要设置矩形指针了为了打印字体的时候以矩形为边界自动填充。它的格式是RECT r={X1,Y1,X2,Y2},X1和X2是矩形的左边和右边的横坐标,Y1和Y2是矩形的上边和下边的纵坐标,这一点和rectangle()绘制空心矩形函数参数排列一致。后面的DT_CENTER | DT_VCENTER | DT_SINGLELINE就是描述填充格式的常量。使用drawtext书写文字不需要再计算文字的坐标和设置大小,会方便很多。
    \qquad LOGFONT是字体样式指针,通过gettextstyle()函数来获取当前的字体类型,再通过settextstyle()函数加以设置。这里只修改了字体的名称和显示质量,还可以修改斜体、下划线等属性,更详细的部分请参考帮助文档。

    2.3.鼠标操作

    2.3.1.单击特效

    \qquad 作为一个图形化界面的C程序,鼠标操作总不能少吧。在讲解程序前先别着急,简单为大家科普一下鼠标事件:
    \qquad 鼠标是输入设备,只要发生以下的事件,就会暂存在鼠标消息列表中,我们的操作系统就会依次响应列表中的鼠标消息事件,常用的鼠标事件如下:

    • WM_MOUSEMOVE——鼠标移动
    • WM_MOUSEWHEEL——鼠标滚轮滚动
    • WM_LBUTTONDOWN——鼠标左键按下
    • WM_LBUTTONUP——鼠标左键弹起
    • WM_LBUTTONDBLCLK——鼠标左键双击
    • WM_RBUTTONDOWN——鼠标右键按下
    • WM_RBUTTONUP——鼠标右键弹起
    • WM_RBUTTONDBLCLK——鼠标左键双击
    • WM_MBUTTONDOWN——鼠标中键按下
    • WM_MBUTTONUP——鼠标中键弹起
    • WM_MBUTTONDBLCLK——鼠标中键双击
      \qquad 我们只需要根据不断获取鼠标消息队列的消息并根据消息依次进行响应即可。

    \qquad 相信大家已经迫不及待了,那么请看下面一个简单的程序。

    #include <graphics.h>              // 引用图形库头文件
    #include <conio.h>
    #include <stdio.h>
    #include <windows.h>				//用到了定时函数sleep()
    #include <math.h>
    int r1[]={30,20,130,60};//输入按钮的矩形参数
    int r2[]={170,20,220,60};//运行按钮的矩形参数
    int r3[]={260,20,310,60};//退出按钮的矩形参数
    int main()
    {
    	int i;
    	short win_width,win_height;//定义窗口的宽度和高度
    	win_width = 480;win_height = 360;
    	initgraph(win_width,win_height);//初始化窗口(黑屏)
    	for(i=0;i<256;i+=5)
    	{
    		setbkcolor(RGB(i,i,i));//设置背景色,原来默认黑色
    		cleardevice();//清屏(取决于背景色)
    		Sleep(15);//延时15ms
    	}
    	RECT R1={r1[0],r1[1],r1[2],r1[3]};//按钮1的矩形区域
    	RECT R2={r2[0],r2[1],r2[2],r2[3]};//按钮2的矩形区域
    	RECT R3={r3[0],r3[1],r3[2],r3[3]};//按钮2的矩形区域
    	LOGFONT f;
    	gettextstyle(&f);					//获取字体样式
    	_tcscpy(f.lfFaceName,_T("宋体"));	//设置字体为宋体
    	f.lfQuality = ANTIALIASED_QUALITY;    // 设置输出效果为抗锯齿  
    	settextstyle(&f);                     // 设置字体样式
    	settextcolor(BLACK);				//BLACK在graphic.h头文件里面被定义为黑色的颜色常量
    	drawtext("输入参数",&R1,DT_CENTER | DT_VCENTER | DT_SINGLELINE);//在矩形区域R1内输入文字,水平居中,垂直居中,单行显示
    	drawtext("运行",&R2,DT_CENTER | DT_VCENTER | DT_SINGLELINE);//在矩形区域R2内输入文字,水平居中,垂直居中,单行显示
    	drawtext("退出",&R3,DT_CENTER | DT_VCENTER | DT_SINGLELINE);//在矩形区域R3内输入文字,水平居中,垂直居中,单行显示
    	setlinecolor(BLACK);
    	rectangle(r1[0],r1[1],r1[2],r1[3]);
    	rectangle(r2[0],r2[1],r2[2],r2[3]);
    	rectangle(r3[0],r3[1],r3[2],r3[3]);
    	MOUSEMSG m;//鼠标指针
    	setrop2(R2_NOTXORPEN);//二元光栅——NOT(屏幕颜色 XOR 当前颜色)
    	while(true)
    	{
    		m = GetMouseMsg();//获取一条鼠标消息
    		if(m.uMsg==WM_LBUTTONDOWN)
    		{
    			for(i=0;i<=10;i++)
    			{
    				setlinecolor(RGB(25*i,25*i,25*i));//设置圆颜色
    				circle(m.x,m.y,2*i);
    				Sleep(25);//停顿2ms
    				circle(m.x,m.y,2*i);//抹去刚刚画的圆
    			}
    			FlushMouseMsgBuff();//清空鼠标消息缓存区
    		}
    	}
    	system("pause");//暂停,为了显示
    	closegraph();
    	return 0;
    }
    
    
    

    在这里插入图片描述
    \qquad 每点击鼠标以下,应该可以看到鼠标点击处有一个逐渐扩大并淡出的圆(截图无法清晰,在画面的中右侧),当循环体内Sleep的视觉大于20ms后视觉效果很强。
    \qquad 每响应一次鼠标左键单击事件,都会调用一次清空鼠标消息缓存区的函数FlushMouseMsgBuff(),如果没有这个函数会怎么样呢?如果我们快速连续地单击鼠标左键N次,那么特效就会播放N次,如果特效播放速度比单击的速度慢,那么即使你停下来了,程序仍然会接着播放单击特效,因为你的左键单击仍然在鼠标的消息队列m.uMsg中的鼠标消息没有响应完。
    \qquad 这里需要解释的是一个二元光栅设置函数setrop2(),二元光栅是混合背景色和当前颜色的模式。我们这里采用的方式是同或(NOT XOR)的方式,若底色为白色(1),则当前颜色不变;若底色是黑色(0),则当前颜色反色。为什么需要采用这种方式呢?因为我们在第二次抹去原来的圆的时候不能采用白色,否则如果背景色原来就为黑(比如按钮和文字),就也会被抹成白色。而背景色与任意一个颜色同或两次都为其本身,即可起到还原背景色的效果。这里的背景色与cleardevice()前面那个背景色不同,这里的是指执行这一条绘画指令之前屏幕上的颜色。

    2.3.2.光标感应

    \qquad 我们希望鼠标移到按钮上时按钮会有所变化,移开按钮时又会回到原样。这里我们采用一种简单的填充颜色的方法,就是按钮变色。我们需要解决一个问题就是按钮变色了但是按钮的文字不能被覆盖,那么我们还是需要使用到二元光栅。只是我们这次的模式改成了同或。
    \qquad 为了方便起见,存放三个按钮的数组我们合并为了一个二维数组,在鼠标事件中更容易使用和分配任务。

    #include <graphics.h>              // 引用图形库头文件
    #include <conio.h>
    #include <stdio.h>
    #include <windows.h>				//用到了定时函数sleep()
    #include <math.h>
    int r[3][4]={{30,20,130,60},{170,20,220,60},{260,20,310,60}};//三个按钮的二维数组
    
    int button_judge(int x,int y)
    {
    	if(x>r[0][0] && x<r[0][2] && y>r[0][1] && y<r[0][3])return 1;
    	if(x>r[1][0] && x<r[1][2] && y>r[1][1] && y<r[1][3])return 2;
    	if(x>r[2][0] && x<r[2][2] && y>r[2][1] && y<r[2][3])return 3;
    	return 0;
    }
    int main()
    {
    	int i,event=0;
    	short win_width,win_height;//定义窗口的宽度和高度
    	win_width = 480;win_height = 360;
    	initgraph(win_width,win_height);//初始化窗口(黑屏)
    	for(i=0;i<256;i+=5)
    	{
    		setbkcolor(RGB(i,i,i));//设置背景色,原来默认黑色
    		cleardevice();//清屏(取决于背景色)
    		Sleep(15);//延时15ms
    	}
    	RECT R1={r[0][0],r[0][1],r[0][2],r[0][3]};
    	RECT R2={r[1][0],r[1][1],r[1][2],r[1][3]};
    	RECT R3={r[2][0],r[2][1],r[2][2],r[2][3]};
    	LOGFONT f;
    	gettextstyle(&f);					//获取字体样式
    	_tcscpy(f.lfFaceName,_T("宋体"));	//设置字体为宋体
    	f.lfQuality = ANTIALIASED_QUALITY;    // 设置输出效果为抗锯齿  
    	settextstyle(&f);                     // 设置字体样式
    	settextcolor(BLACK);				//BLACK在graphic.h头文件里面被定义为黑色的颜色常量
    	drawtext("输入参数",&R1,DT_CENTER | DT_VCENTER | DT_SINGLELINE);//在矩形区域R1内输入文字,水平居中,垂直居中,单行显示
    	drawtext("运行",&R2,DT_CENTER | DT_VCENTER | DT_SINGLELINE);//在矩形区域R2内输入文字,水平居中,垂直居中,单行显示
    	drawtext("退出",&R3,DT_CENTER | DT_VCENTER | DT_SINGLELINE);//在矩形区域R3内输入文字,水平居中,垂直居中,单行显示
    	setlinecolor(BLACK);
    	rectangle(r[0][0],r[0][1],r[0][2],r[0][3]);
    	rectangle(r[1][0],r[1][1],r[1][2],r[1][3]);
    	rectangle(r[2][0],r[2][1],r[2][2],r[2][3]);
    	MOUSEMSG m;//鼠标指针
    	
    	while(true)
    	{
    		m = GetMouseMsg();//获取一条鼠标消息
    
    		switch(m.uMsg)
    		{
    			case WM_MOUSEMOVE:
    				setrop2(R2_XORPEN);
    				setlinecolor(LIGHTCYAN);//线条颜色为亮青色
    				setlinestyle(PS_SOLID, 3);//设置画线样式为实现,10磅
    				setfillcolor(WHITE);//填充颜色为白色
    				if(button_judge(m.x,m.y)!=0)
    				{
    					if(event != button_judge(m.x,m.y))
    					{
    						event = button_judge(m.x,m.y);//记录这一次触发的按钮
    						fillrectangle(r[event-1][0],r[event-1][1],r[event-1][2],r[event-1][3]);//有框填充矩形(X1,Y1,X2,Y2)
    					}
    				}
    				else
    				{
    					if(event != 0)//上次触发的按钮未被修正为原来的颜色
    					{
    						fillrectangle(r[event-1][0],r[event-1][1],r[event-1][2],r[event-1][3]);//两次同或为原来颜色
    						event = 0;
    					}
    				}
    				break;
    			case WM_LBUTTONDOWN:
    				setrop2(R2_NOTXORPEN);//二元光栅——NOT(屏幕颜色 XOR 当前颜色)
    				for(i=0;i<=10;i++)
    				{
    					setlinecolor(RGB(25*i,25*i,25*i));//设置圆颜色
    					circle(m.x,m.y,2*i);
    					Sleep(30);//停顿30ms
    					circle(m.x,m.y,2*i);//抹去刚刚画的圆
    				}
    				break;
    				FlushMouseMsgBuff();//清空鼠标消息缓存区
    		}
    	}
    	system("pause");//暂停,为了显示
    	return 0;
    }
    
    

    在这里插入图片描述
    \qquad 这里我们运用了两次设置二元光栅的函数setrop2,在鼠标的移动条件内(case MOUSEMOVE),我们使用的是屏幕颜色和当前颜色异或,这是为什么呢?因为fillrectangle()函数是画一个有框填充矩形,我们让这个有框填充矩形和原按钮的一样大。由于线条的颜色为亮青色,填充颜色为白色(1),白色的填充颜色和屏幕颜色异或,取的是屏幕颜色的反色。按钮的边框是黑色(0),它与亮青色异或,则会保留原来的亮青色。
    \qquad 与同或一样,异或两次等于没有执行操作,所以可以还原到原屏幕画布的颜色。

    2.3.3.进度条

    \qquad 既然涉及到进度条了,那么就应该涉及到正式程序了,这里我不想涉及太多的专业知识影响大家理解,但又不能让程序运行得太快以至于看不出进度条的变化,所以我设计了一个简单的弹性球轨迹作图程序。
    \qquad 假设球半径为R,初始高度为 h 0 h_0 h0,初速度为0(自由落体),非弹性碰撞时能量损失率为 α \alpha α。计算部分子函数如下:

    int simulation()
    {
    	float dt = 0.01;//仿真间隔10ms
    	long int N = (long int)(sim_t/dt);//迭代次数
    	float *h=(float*)calloc(N,sizeof(float));//高度
    	float *v=(float*)calloc(N,sizeof(float));//速度(竖直方向)
    	long int i;//迭代变量
    	for(i=1;i<N;i++)
    	{
    		if(h[i-1]>R)//未发生碰撞
    		{
    			v[i]=v[i-1]-9.8*dt;//速度计算
    		}
    		else//发生碰撞,动能损失alpha,速度损失alpha的开方
    		{
    			v[i]=-sqrt(alpha)*v[i-1];	
    		}
    	}
    	free(h);
    	free(v);//释放内存
    	return 0;
    }
    

    \qquad 当然,我们还需要绘图网格,定义绘图网格的函数如下:

    void init_figure()
    {
    	int i;
    	setrop2(R2_COPYPEN);//当前颜色
    	setlinecolor(BLACK);
    	setlinestyle(PS_SOLID);//实线
    	rectangle(30,100,420,330);//外框线
    	setlinestyle(PS_DOT);//点线
    	for(i=30+39;i<420;i+=39)
    	{
    		line(i,100,i,330);//竖直辅助线
    	}
    	for(i=100+23;i<330;i+=23)
    	{
    		line(30,i,420,i);//水平辅助线
    	}
    }
    

    \qquad 注意,我们使用了rectangle()空心矩形函数绘制网格外框架,使用了line函数依次画出了辅助线。

    \qquad 我们现在的目标就是将h的坐标转换到网格上去,绘制出球心的轨迹,这样似乎并不复杂,只需要对simulation()函数稍加修改即可。

    int simulation()
    {
    	float dt = 0.01;//仿真间隔10ms
    	float dy = 230/h0;//单位纵坐标
    	long int N = (long int)(sim_t/dt);//迭代次数
    	float *h=(float*)calloc(N,sizeof(float));//高度
    	float *v=(float*)calloc(N,sizeof(float));//速度(竖直方向)
    	long int i;//迭代变量
    	float process_duty;//进度
    	init_figure();//初始化图像网格
    	setrop2(R2_COPYPEN);//当前颜色
    	//计算步骤
    	h[0]=h0;v[0]=0;
    	for(i=1;i<N;i++)
    	{
    		if(h[i-1]>R)//未发生碰撞
    		{
    			v[i]=v[i-1]-9.8*dt;//速度计算
    		}
    		else//发生碰撞,动能损失alpha,速度损失alpha的开方
    		{
    			v[i]=-sqrt(alpha)*v[i-1];	
    		}
    		h[i]=h[i-1]+v[i]*dt;//高度计算
    		process_duty = (i+1)/(float)(N);
    		putpixel(30+(int)(process_duty*390),330-(int)(h[i]*dy),RED);//画点putpixel(X,Y,color*)
    		Sleep(dt*1000);//延时
    	}
    	free(h);
    	free(v);
    	return 0;
    }
    

    \qquad 这里的新函数putpixel(X,Y,color*)是画像素点的函数,适合刻画不连续或不规则的移动轨迹。
    \qquad 现在我们只剩下了刻画进度条的函数了,进度条的刷新很明显是应该放在for循环里面的,那么我们采用什么进度条的格式呢?进度条可以有圆形、扇形、长条连续型、长条不连续型等多种,我们这里采用的是环形进度条,将进度数字显示在环中心。请看以下的对simulation()函数改进的代码:

    //仿真运行
    int simulation()
    {
    	char t[3];//百分值的字符
    	char *out_text;//带百分号的百分字符
    	float dt = 0.01;//仿真间隔10ms
    	float dy = 230/h0;//单位纵坐标
    	long int N = (long int)(sim_t/dt);//迭代次数
    	float *h=(float*)calloc(N,sizeof(float));//高度
    	float *v=(float*)calloc(N,sizeof(float));//速度(竖直方向)
    	long int i;//迭代变量
    	float process_duty;//进度
    	RECT r={370,35,400,65};//百分值显示区域的矩形指针
    	init_figure();//初始化图像网格
    	setrop2(R2_COPYPEN);//当前颜色
    	setfillcolor(WHITE);
    	setlinecolor(WHITE);
    	fillrectangle(354,19,411,81);//覆盖原进度条区域
    	setlinestyle(PS_NULL);//无线条
    	setbkmode(TRANSPARENT);//设置文字填充背景为透明
    	//计算步骤
    	h[0]=h0;v[0]=0;
    	BeginBatchDraw();//开始缓存区
    	for(i=1;i<N;i++)
    	{
    		if(h[i-1]>R)//未发生碰撞
    		{
    			v[i]=v[i-1]-9.8*dt;//速度计算
    		}
    		else//发生碰撞,动能损失alpha,速度损失alpha的开方
    		{
    			v[i]=-sqrt(alpha)*v[i-1];	
    		}
    		setfillcolor(WHITE);
    		setlinecolor(WHITE);
    		fillrectangle(354,19,416,81);//覆盖原进度条区域
    		h[i]=h[i-1]+v[i]*dt;//高度计算
    		process_duty = (i+1)/(float)(N);
    		setlinestyle(PS_SOLID);
    		putpixel(30+(int)(process_duty*390),330-(int)(h[i]*dy),RED);
    		setfillcolor(BLUE);
    		setlinestyle(PS_NULL);
    		fillpie(355,20,415,80,0,process_duty*2*PI);
    		setfillcolor(WHITE);
    		fillcircle(385,50,20);
    		sprintf(t,"%d",(int)(process_duty*100.0));//整型转换为字符串
    		out_text = strcat(t,"%");//添加一个百分号
    		drawtext(out_text,&r,DT_CENTER | DT_VCENTER | DT_SINGLELINE);
    		Sleep(dt*1000);
    		FlushBatchDraw();//刷新缓存区
    	}
    	EndBatchDraw();//结束缓存区
    	free(h);
    	free(v);
    	return 0;
    }
    

    \qquad 这里我们需要多加载一个头文件<string.h>。
    \qquad 首先需要计算进度条的坐标,把环形进度条区域用白色矩形刷新掉,环形进度条需要一个扇形和圆形的组合,扇形的角度是0~360°。这里我们用到了fillpie(X1,Y1,X2,Y2,start_angle,end_angle),前四个参数为椭圆扇形的外接矩形坐标,后两个参数分别为起始角和终止角(弧度制)。每过一次迭代都重新计算终止角(起始角始终为0),即可起到扇形角度逐渐增长的效果,再用一个白色填充圆覆盖中心部分即可变成环形进度条。
    \qquad FlushBatchDraw()函数是刷新缓存区的函数,与BeginBatchDraw()EndBatchDraw()一起使用,如果我们绘图之后不想立即显示,而想批量绘图最后一起刷新画板,用缓存区的方法再合适不过了。

    3.完整代码及效果

    #include <graphics.h>              // 引用图形库头文件
    #include <conio.h>
    #include <stdio.h>
    #include <windows.h>				//用到了定时函数sleep()
    #include <math.h>
    #include <string.h>
    #define PI 3.1416
    int r[3][4]={{30,20,130,60},{170,20,220,60},{260,20,310,60}};//三个按钮的二维数组
    float alpha,R,h0,sim_t;//碰撞时的能量损失率,球的半径、初始高度、仿真时间
    //按钮判断函数
    int button_judge(int x,int y)
    {
    	if(x>r[0][0] && x<r[0][2] && y>r[0][1] && y<r[0][3])return 1;
    	if(x>r[1][0] && x<r[1][2] && y>r[1][1] && y<r[1][3])return 2;
    	if(x>r[2][0] && x<r[2][2] && y>r[2][1] && y<r[2][3])return 3;
    	return 0;
    }
    //初始化图像
    void init_figure()
    {
    	int i;
    	setrop2(R2_COPYPEN);//当前颜色
    	setlinecolor(BLACK);
    	setlinestyle(PS_SOLID);//实线
    	rectangle(30,100,420,330);//外框线
    	setlinestyle(PS_DOT);//点线
    	for(i=30+39;i<420;i+=39)
    	{
    		line(i,100,i,330);//竖直辅助线
    	}
    	for(i=100+23;i<330;i+=23)
    	{
    		line(30,i,420,i);//水平辅助线
    	}
    }
    //仿真运行
    int simulation()
    {
    	char t[3];//百分值的字符
    	char *out_text;
    	float dt = 0.01;//仿真间隔10ms
    	float dy = 230/h0;//单位纵坐标
    	long int N = (long int)(sim_t/dt);//迭代次数
    	float *h=(float*)calloc(N,sizeof(float));//高度
    	float *v=(float*)calloc(N,sizeof(float));//速度(竖直方向)
    	long int i;//迭代变量
    	float process_duty;//进度
    	RECT r={370,35,400,65};//百分值显示区域的矩形指针
    	init_figure();//初始化图像网格
    	setrop2(R2_COPYPEN);//当前颜色
    	setfillcolor(WHITE);
    	setlinecolor(WHITE);
    	fillrectangle(354,19,411,81);//覆盖原进度条区域
    	setlinestyle(PS_NULL);//无线条
    	setbkmode(TRANSPARENT);//设置文字填充背景为透明
    	//计算步骤
    	h[0]=h0;v[0]=0;
    	BeginBatchDraw();//开始缓存区
    	for(i=1;i<N;i++)
    	{
    		if(h[i-1]>R)//未发生碰撞
    		{
    			v[i]=v[i-1]-9.8*dt;//速度计算
    		}
    		else//发生碰撞,动能损失alpha,速度损失alpha的开方
    		{
    			v[i]=-sqrt(alpha)*v[i-1];	
    		}
    		setfillcolor(WHITE);
    		setlinecolor(WHITE);
    		fillrectangle(354,19,416,81);//覆盖原进度条区域
    		h[i]=h[i-1]+v[i]*dt;//高度计算
    		process_duty = (i+1)/(float)(N);
    		setlinestyle(PS_SOLID);
    		putpixel(30+(int)(process_duty*390),330-(int)(h[i]*dy),RED);
    		setfillcolor(BLUE);
    		setlinestyle(PS_NULL);
    		fillpie(355,20,415,80,0,process_duty*2*PI);
    		setfillcolor(WHITE);
    		fillcircle(385,50,20);
    		sprintf(t,"%d",(int)(process_duty*100.0));//整型转换为字符串
    		out_text = strcat(t,"%");//添加一个百分号
    		drawtext(out_text,&r,DT_CENTER | DT_VCENTER | DT_SINGLELINE);
    		Sleep(dt*1000);
    		FlushBatchDraw();//刷新缓存区
    	}
    	EndBatchDraw();//结束缓存区
    	free(h);
    	free(v);
    	return 0;
    }
    
    int main()
    {
    	int i,event=0;
    	char s[30];//输入字符串变量
    	short win_width,win_height;//定义窗口的宽度和高度
    	win_width = 480;win_height = 360;
    	initgraph(win_width,win_height);//初始化窗口(黑屏)
    	for(i=0;i<256;i+=5)
    	{
    		setbkcolor(RGB(i,i,i));//设置背景色,原来默认黑色
    		cleardevice();//清屏(取决于背景色)
    		Sleep(30);//延时30ms
    	}
    	RECT R1={r[0][0],r[0][1],r[0][2],r[0][3]};
    	RECT R2={r[1][0],r[1][1],r[1][2],r[1][3]};
    	RECT R3={r[2][0],r[2][1],r[2][2],r[2][3]};
    	LOGFONT f;//字体样式指针
    	gettextstyle(&f);					//获取字体样式
    	_tcscpy(f.lfFaceName,_T("宋体"));	//设置字体为宋体
    	f.lfQuality = ANTIALIASED_QUALITY;    // 设置输出效果为抗锯齿  
    	settextstyle(&f);                     // 设置字体样式
    	settextcolor(BLACK);				//BLACK在graphic.h头文件里面被定义为黑色的颜色常量
    	drawtext("输入参数",&R1,DT_CENTER | DT_VCENTER | DT_SINGLELINE);//在矩形区域R1内输入文字,水平居中,垂直居中,单行显示
    	drawtext("运行",&R2,DT_CENTER | DT_VCENTER | DT_SINGLELINE);//在矩形区域R2内输入文字,水平居中,垂直居中,单行显示
    	drawtext("退出",&R3,DT_CENTER | DT_VCENTER | DT_SINGLELINE);//在矩形区域R3内输入文字,水平居中,垂直居中,单行显示
    	setlinecolor(BLACK);
    	rectangle(r[0][0],r[0][1],r[0][2],r[0][3]);
    	rectangle(r[1][0],r[1][1],r[1][2],r[1][3]);
    	rectangle(r[2][0],r[2][1],r[2][2],r[2][3]);
    	MOUSEMSG m;//鼠标指针
    	
    	while(true)
    	{
    		m = GetMouseMsg();//获取一条鼠标消息
    
    		switch(m.uMsg)
    		{
    			case WM_MOUSEMOVE:
    				setrop2(R2_XORPEN);
    				setlinecolor(LIGHTCYAN);//线条颜色为亮青色
    				setlinestyle(PS_SOLID, 3);//设置画线样式为实现,10磅
    				setfillcolor(WHITE);//填充颜色为白色
    				if(button_judge(m.x,m.y)!=0)
    				{
    					if(event != button_judge(m.x,m.y))
    					{
    						event = button_judge(m.x,m.y);//记录这一次触发的按钮
    						fillrectangle(r[event-1][0],r[event-1][1],r[event-1][2],r[event-1][3]);//有框填充矩形(X1,Y1,X2,Y2)
    					}
    				}
    				else
    				{
    					if(event!=0)//上次触发的按钮未被修正为原来的颜色
    					{
    						fillrectangle(r[event-1][0],r[event-1][1],r[event-1][2],r[event-1][3]);//两次同或为原来颜色
    						event = 0;
    					}
    				}
    				break;
    			case WM_LBUTTONDOWN:
    				setrop2(R2_NOTXORPEN);//二元光栅——NOT(屏幕颜色 XOR 当前颜色)
    				for(i=0;i<=10;i++)
    				{
    					setlinecolor(RGB(25*i,25*i,25*i));//设置圆颜色
    					circle(m.x,m.y,2*i);
    					Sleep(20);//停顿30ms
    					circle(m.x,m.y,2*i);//抹去刚刚画的圆
    				}
    				//按照按钮判断左键单击后的操作
    				switch(button_judge(m.x,m.y))
    				{
    					//复原按钮原型
    					case 1:
    						InputBox(s,30,"请输入碰撞时的能量损失率、球的半径、初始高度、仿真时间");
    						sscanf(s,"%f%f%f%f",&alpha,&R,&h0,&sim_t);//将输入字符串依次扫描到全局变量里面
    						FlushMouseMsgBuffer();//单击事件后清空鼠标消息
    						break;
    					case 2:
    						simulation();//仿真运行
    						FlushMouseMsgBuffer();//单击事件后清空鼠标消息
    						break;
    					case 3:
    						closegraph();//关闭绘图环境
    						exit(0);//正常退出
    					default:
    						FlushMouseMsgBuffer();//单击事件后清空鼠标消息
    						//printf("\r\n(%d,%d)",m.x,m.y);//打印鼠标坐标,方便调试时确定区域
    						break;
    				}
    				break;
    		}
    	}
    	return 0;
    }
    
    

    在这里插入图片描述
    在这里插入图片描述
    希望本文对您有帮助,谢谢阅读。

    展开全文
  • sqlserver图形化界面

    2013-06-01 12:00:47
    sqlserver图形化界面适合安装了 sqlserver精简版的朋友,还有win7下29506错误解决,需要精简版的朋友可以搜索我的资源
  • Windows7配置PuTTY+Xming连接CentOS7 SSH服务器图形化界面.........
  • 个人总结的linux安装oracle图形化界面时面临的各种问题的解决方法
  • Python 图形化界面设计

    万次阅读 多人点赞 2019-05-30 21:40:24
    1、图形化界面设计的基本理解 当前流行的计算机桌面应用程序大多数为图形化用户界面(Graphic User Interface,GUI),即通过鼠标对菜单、按钮等图形化元素触发指令,并从标签、对话框等图型化显示容器中获取人机对话...

    1、图形化界面设计的基本理解

    当前流行的计算机桌面应用程序大多数为图形化用户界面(Graphic User Interface,GUI),即通过鼠标对菜单、按钮等图形化元素触发指令,并从标签、对话框等图型化显示容器中获取人机对话信息。
    Python自带了tkinter 模块,实质上是一种流行的面向对象的GUI工具包 TK 的Python编程接口,提供了快速便利地创建GUI应用程序的方法。其图像化编程的基本步骤通常包括:

    • 导入 tkinter 模块
    • 创建 GUI 根窗体
    • 添加人机交互控件并编写相应的函数。
    • 在主事件循环中等待用户触发事件响应。

    2、窗体控件布局

    • 2.1、根窗体是图像化应用程序的根控制器,是tkinter的底层控件的实例。当导入tkinter模块后,调用 Tk()方法可初始化一个根窗体实例 root ,用 title() 方法可设置其标题文字,用geometry()方法可以设置窗体的大小(以像素为单位)。将其置于主循环中,除非用户关闭,否则程序始终处于运行状态。执行该程序,一个窗体就呈现出来了。在这个主循环的根窗体中,可持续呈现中的其他可视化控件实例,监测事件的发生并执行相应的处理程序。下面是根窗体呈现示例:

       
      1. from tkinter import *

      2. root= Tk()

      3. root.title('我的第一个Python窗体')

      4. root.geometry('240x240') # 这里的乘号不是 * ,而是小写英文字母 x

      5. root.mainloop()

      根窗体呈现示例

    • 2.2、tkinter 常用控件

      控件名称作用
      Button按钮单击触发事件
      Canvas画布绘制图形或绘制特殊控件
      Checkbutton复选框多项选择
      Entry输入框接收单行文本输入
      Frame框架用于控件分组
      Label标签单行文本显示
      Lisbox列表框显示文本列表
      Menu菜单创建菜单命令
      Message消息多行文本标签,与Label 用法类似
      Radiobutton单选按钮从互斥的多个选项中做单项选择
      Scale滑块默认垂直方向,鼠标拖动改变数值形成可视化交互
      Scrollbar滑动条默认垂直方向,课鼠标拖动改变数值,可与 Text、Lisbox、Canvas等控件配合移动可视化空间
      Text文本框接收或输出显示多行文本
      Toplevel新建窗体容器在顶层创建新窗体
      • 常用控件:常用的10 多种,如下:
      • 控件的共同属性:在窗体上呈现的可视化控件,通常包括尺寸、颜色、字体、相对位置、浮雕样式、图标样式和悬停光标形状等共同属性。不同的控件由于形状和功能不同,又有其特征属性。在初始化根窗体和根窗体主循环之间,可实例化窗体控件,并设置其属性。父容器可为根窗体或其他容器控件实例。常见的控件共同属性如下表:

        属性说明取值
        anchor文本起始位置CENTER(默认),E,S,W,N,NE,SE,SW,NW
        bg背景色
        bd加粗(默认 2 像素)
        bitmap黑白二值图标网上查找
        cursor鼠标悬停光标网上查找
        font字体
        fg前景色
        height高(文本控件的单位为行,不是像素)
        image显示图像
        justify多行文本的对其方式CENTER(默认),LEFT,RIGHT,TOP,BOTTOM
        padx水平扩展像素
        pady垂直扩展像素
        relief3D浮雕样式FLAT,RAISED,SUNKEN,GROOVE,RIDGE
        state控件实例状态是否可用NORMAL(默认),DISABLED
        width宽(文本控件的单位为行,不是像素)

        标签及常见属性示例:

         
        1. from tkinter import *

        2. root = Tk()

        3. lb = Label(root,text='我是第一个标签',\

        4. bg='#d3fbfb',\

        5. fg='red',\

        6. font=('华文新魏',32),\

        7. width=20,\

        8. height=2,\

        9. relief=SUNKEN)

        10. lb.pack()

        11. root.mainloop()

         


        其中,标签实例lb 在父容器root中实例化,具有代码中所示的text(文本)、bg(背景色)、fg(前景色)、font(字体)、width(宽,默认以字符为单位)、height(高,默认以字符为单位)和 relief(浮雕样式)等一系列属性。
        在实例化控件时,实例的属性可以“属性=属性值”的形式枚举列出,不区分先后次序。例如:“ text='我是第一个标签' ”显示标签的文本内容,“bg='#d3fbfb'”设置背景色为十六进制数RGB色 #d3fbfb等等。属性值通常用文本形式表示。
        当然如果这个控件实例只需要一次性呈现,也可以不必命名,直接实例化并布局呈现出来,例如:

         

        Label(root,text='我是第一个标签',font='华文新魏').pack()
        

    属性 relief 为控件呈现出来的3D浮雕样式,有 FLAT(平的)、RAISED(凸起的)、SUNKEN(凹陷的)、GROOVE(沟槽状边缘)和 RIDGE(脊状边缘) 5种。

     

    控件呈现的5种浮雕样式

    • 2.2、控件布局
      控件的布局通常有pack()grid() 和 place() 三种方法。

      • 2.2.1、pack()方法:是一种简单的布局方法,如果不加参数的默认方式,将按布局语句的先后,以最小占用空间的方式自上而下地排列控件实例,并且保持控件本身的最小尺寸。如下的例子:

        •  

           

          用pack() 方法不加参数排列标签。为看清楚各控件所占用的空间大小,文本用了不同长度的中英文,并设置relief=GROOVE的凹陷边缘属性。如下所示:

           
          1. from tkinter import *

          2. root = Tk()

          3.  
          4. lbred = Label(root,text="Red",fg="Red",relief=GROOVE)

          5. lbred.pack()

          6. lbgreen = Label(root,text="绿色",fg="green",relief=GROOVE)

          7. lbgreen.pack()

          8. lbblue = Label(root,text="蓝",fg="blue",relief=GROOVE)

          9. lbblue.pack()

          10. root.mainloop()

        • 使用pack()方法可设置 fill、side 等属性参数。其中,参数fill 可取值:fill=X,fill=Y或fill=BOTH,分别表示允许控件向水平方向、垂直方向或二维伸展填充未被占用控件。参数 side 可取值:side=TOP(默认),side=LEFT,side=RIGHT,side=BOTTOM,分别表示本控件实例的布局相对于下一个控件实例的方位。如下例子:

           

          用pack()方法加参数排列标签

           
          1. from tkinter import *

          2. root = Tk()

          3.  
          4. lbred = Label(root,text="Red",fg="Red",relief=GROOVE)

          5. lbred.pack()

          6. lbgreen = Label(root,text="绿色",fg="green",relief=GROOVE)

          7. lbgreen.pack(side=RIGHT)

          8. lbblue = Label(root,text="蓝",fg="blue",relief=GROOVE)

          9. lbblue.pack(fill=X)

          10. root.mainloop()

      • 2.2.2、grid()方法:是基于网格的布局。先虚拟一个二维表格,再在该表格中布局控件实例。由于在虚拟表格的单元中所布局的控件实例大小不一,单元格也没有固定或均一的大小,因此其仅用于布局的定位。pack()方法与grid()方法不能混合使用。
        grid()方法常用布局参数如下:

        看下面的例子:用grid()方法排列标签,设想有一个3x4的表格,起始行、列序号均为0.将标签lbred 至于第2列第0行;将标签lbgreen置于第0列第1行;将标签lbblue置于第1列起跨2列第2行,占20像素宽。

         

        pack()方法排列标签

         
        1. from tkinter import *

        2. root = Tk()

        3.  
        4. lbred = Label(root,text="Red",fg="Red",relief=GROOVE)

        5. lbred.grid(column=2,row=0)

        6. lbgreen = Label(root,text="绿色",fg="green",relief=GROOVE)

        7. lbgreen.grid(column=0,row=1)

        8. lbblue = Label(root,text="蓝",fg="blue",relief=GROOVE)

        9. lbblue.grid(column=1,columnspan=2,ipadx=20,row=2)

        10. root.mainloop()

        • column: 控件实例的起始列,最左边为第0列。
        • columnspan: 控件实例所跨越的列数,默认为1列。
        • ipadx,ipady: 控件实例所呈现区域内部的像素数,用来设置控件实例的大小。
        • padx,pady: 控件实例所占据空间像素数,用来设置实例所在单元格的大小。
        • row: 控件实例的起始行,最上面为第0行。
        • rowspan: 控件实例的起始行数,默认为1行。
      • 2.2.3、place()方法:根据控件实例在父容器中的绝对或相对位置参数进行布局。其常用布局参数如下:

        • x,y:控件实例在根窗体中水平和垂直方向上的其实位置(单位为像素)。注意,根窗体左上角为0,0,水平向右,垂直向下为正方向。

        • relx,rely:控件实例在根窗体中水平和垂直方向上起始布局的相对位置。即相对于根窗体宽和高的比例位置,取值在0.0~1.0之间。

        • height,width:控件实例本身的高度和宽度(单位为像素)。

        • relheight,relwidth:控件实例相对于根窗体的高度和宽度比例,取值在0.0~1.0之间。

        • 利用place()方法配合relx,rely和relheight,relwidth参数所得的到的界面可自适应根窗体尺寸的大小。place()方法与grid()方法可以混合使用。如下例子:利用place()方法排列消息(多行标签)。

           

          place()方法排列消息

           
          1. from tkinter import *

          2. root = Tk()

          3. root.geometry('320x240')

          4.  
          5. msg1 = Message(root,text='''我的水平起始位置相对窗体 0.2,垂直起始位置为绝对位置 80 像素,我的高度是窗体高度的0.4,宽度是200像素''',relief=GROOVE)

          6. msg1.place(relx=0.2,y=80,relheight=0.4,width=200)

          7. root.mainloop()

    • 3、tkinter常见控件的特征属性

      • 3.1、文本输入和输出相关控件:文本的输入与输出控件通常包括:标签(Label)、消息(Message)、输入框(Entry)、文本框(Text)。他们除了前述共同属性外,都具有一些特征属性和功能。

        • 标签(Label)和 消息(Message):除了单行与多行的不同外,属性和用法基本一致,用于呈现文本信息。值得注意的是:属性text通常用于实例在第一次呈现时的固定文本,而如果需要在程序执行后发生变化,则可以使用下列方法之一实现:1、用控件实例的configure()方法来改变属性text的值,可使显示的文本发生变化;2、先定义一个tkinter的内部类型变量var=StringVar() 的值也可以使显示文本发生变化。
          看下面的一个例子:制作一个电子时钟,用root的after()方法每隔1秒time模块以获取系统当前时间,并在标签中显示出来。

          • 方法一:利用configure()方法或config()来实现文本变化。

             

             
            1. import tkinter

            2. import time

            3.  
            4. def gettime():

            5. timestr = time.strftime("%H:%M:%S") # 获取当前的时间并转化为字符串

            6. lb.configure(text=timestr) # 重新设置标签文本

            7. root.after(1000,gettime) # 每隔1s调用函数 gettime 自身获取时间

            8.  
            9. root = tkinter.Tk()

            10. root.title('时钟')

            11.  
            12. lb = tkinter.Label(root,text='',fg='blue',font=("黑体",80))

            13. lb.pack()

            14. gettime()

            15. root.mainloop()

          • 方法二:利用textvariable变量属性来实现文本变化。

             
            1. import tkinter

            2. import time

            3.  
            4. def gettime():

            5. var.set(time.strftime("%H:%M:%S")) # 获取当前时间

            6. root.after(1000,gettime) # 每隔1s调用函数 gettime 自身获取时间

            7.  
            8. root = tkinter.Tk()

            9. root.title('时钟')

            10. var=tkinter.StringVar()

            11.  
            12. lb = tkinter.Label(root,textvariable=var,fg='blue',font=("黑体",80))

            13. lb.pack()

            14. gettime()

            15. root.mainloop()

        • 文本框(Text)

          文本框的常用方法如下:

          方法功能
          delete(起始位置,[,终止位置])删除指定区域文本
          get(起始位置,[,终止位置])获取指定区域文本
          insert(位置,[,字符串]...)将文本插入到指定位置
          see(位置)在指定位置是否可见文本,返回布尔值
          index(标记)返回标记所在的行和列
          mark_names()返回所有标记名称
          mark_set(标记,位置)在指定位置设置标记
          mark_unset(标记)去除标记

          上表位置的取值可为整数,浮点数或END(末尾),例如0.0表示第0列第0行
          如下一个例子:每隔1秒获取一次当前日期的时间,并写入文本框中,如下:本例中调用 datetime.now()获取当前日期时间,用insert()方法每次从文本框txt的尾部(END)开始追加文本。

          获取当前日期的时间并写入文本中

           

           
          1. from tkinter import *

          2. import time

          3. import datetime

          4.  
          5. def gettime():

          6. s=str(datetime.datetime.now())+'\n'

          7. txt.insert(END,s)

          8. root.after(1000,gettime) # 每隔1s调用函数 gettime 自身获取时间

          9.  
          10. root=Tk()

          11. root.geometry('320x240')

          12. txt=Text(root)

          13. txt.pack()

          14. gettime()

          15. root.mainloop()

        • 输入框(Entry):通常作为功能比较单一的接收单行文本输入的控件,虽然也有许多对其中文本进行操作的方法,但通常用的只有取值方法get()和用于删除文本的delete(起始位置,终止位置),例如:清空输入框为delete(0,END)。

      • 3.2、按钮(Button):主要是为响应鼠标单击事件触发运行程序所设的,故其除控件共有属性外,属性command是最为重要的属性。通常,将按钮要触发执行的程序以函数形式预先定义,然后可以用一下两种方法调用函数。Button按钮的状态有:'normal','active','disabled'

        • 直接调用函数。参数表达式为“command=函数名”,注意函数名后面不要加括号,也不能传递参数。如下面的command=run1:

        • 利用匿名函数调用函数和传递参数。参数的表达式为“command=lambda”:函数名(参数列表)。例如下面的:"command=lambda:run2(inp1.get(),inp2.get())"。

        • 看下面的例子:1.从两个输入框去的输入文本后转为浮点数值进行加法运算,要求每次单击按钮产生的算是结果以文本的形式追加到文本框中,将原输入框清空。2.按钮方法一不传参数调用函数run1()实现,按钮“方法二”用lambda调用函数run2(x,y)同时传递参数实现。

           

          简单加法器

           
          1. from tkinter import *

          2.  
          3. def run1():

          4. a = float(inp1.get())

          5. b = float(inp2.get())

          6. s = '%0.2f+%0.2f=%0.2f\n' % (a, b, a + b)

          7. txt.insert(END, s) # 追加显示运算结果

          8. inp1.delete(0, END) # 清空输入

          9. inp2.delete(0, END) # 清空输入

          10.  
          11. def run2(x, y):

          12. a = float(x)

          13. b = float(y)

          14. s = '%0.2f+%0.2f=%0.2f\n' % (a, b, a + b)

          15. txt.insert(END, s) # 追加显示运算结果

          16. inp1.delete(0, END) # 清空输入

          17. inp2.delete(0, END) # 清空输入

          18.  
          19. root = Tk()

          20. root.geometry('460x240')

          21. root.title('简单加法器')

          22.  
          23. lb1 = Label(root, text='请输入两个数,按下面两个按钮之一进行加法计算')

          24. lb1.place(relx=0.1, rely=0.1, relwidth=0.8, relheight=0.1)

          25. inp1 = Entry(root)

          26. inp1.place(relx=0.1, rely=0.2, relwidth=0.3, relheight=0.1)

          27. inp2 = Entry(root)

          28. inp2.place(relx=0.6, rely=0.2, relwidth=0.3, relheight=0.1)

          29.  
          30. # 方法-直接调用 run1()

          31. btn1 = Button(root, text='方法一', command=run1)

          32. btn1.place(relx=0.1, rely=0.4, relwidth=0.3, relheight=0.1)

          33.  
          34. # 方法二利用 lambda 传参数调用run2()

          35. btn2 = Button(root, text='方法二', command=lambda: run2(inp1.get(), inp2.get()))

          36. btn2.place(relx=0.6, rely=0.4, relwidth=0.3, relheight=0.1)

          37.  
          38. # 在窗体垂直自上而下位置60%处起,布局相对窗体高度40%高的文本框

          39. txt = Text(root)

          40. txt.place(rely=0.6, relheight=0.4)

          41.  
          42. root.mainloop()

      • 3.3、单选按钮:(Radiobutton)是为了响应故乡排斥的若干单选项的单击事件以触发运行自定义函数所设的,该控件排除具有共有属性外,还具有显示文本(text)、返回变量(variable)、返回值(value)、响应函数名(command)等重要属性。响应函数名“command=函数名”的用法与Button相同,函数名最后也要加括号。返回变量variable=var通常应预先声明变量的类型var=IntVar()或var=StringVar(),在所调用的函数中方可用var.get()方法获取被选中实例的value值。例如下面:

        单选按钮

         

         
        1. from tkinter import *

        2. def Mysel():

        3. dic = {0:'甲',1:'乙',2:'丙'}

        4. s = "您选了" + dic.get(var.get()) + "项"

        5. lb.config(text = s)

        6.  
        7. root = Tk()

        8. root.title('单选按钮')

        9. lb = Label(root)

        10. lb.pack()

        11.  
        12. var = IntVar()

        13. rd1 = Radiobutton(root,text="甲",variable=var,value=0,command=Mysel)

        14. rd1.pack()

        15.  
        16. rd2 = Radiobutton(root,text="乙",variable=var,value=1,command=Mysel)

        17. rd2.pack()

        18.  
        19. rd3 = Radiobutton(root,text="丙",variable=var,value=2,command=Mysel)

        20. rd3.pack()

        21.  
        22. root.mainloop()

      • 3.4、复选框:(Checkbutton) 是为了返回多个选项值的交互控件,通常不直接触发函数的执行。该控件除具有共有属性外,还具有显示文本(text)、返回变量(variable)、选中返回值(onvalue)和未选中默认返回值(offvalue)等重要属性。返回变量variable=var 通常可以预先逐项分别声明变量的类型var=IntVar() (默认)或 var=StringVar(), 在所调用的函数中方可分别调用 var.get()方法 取得被选中实例的 onvalue或offvalue值。复选框实例通常还可分别利用 select()、deselect()和 toggle() 方法对其进行选中、清除选中和反选操作。

        • 如下的例子: 利用复选框实现,单击OK,可以将选中的结果显示在标签上。效果如下:

           

          复选框的应用

          • 方法:利用函数中的 if-else 分支实现多项显示

             
            1. from tkinter import *

            2. import tkinter

            3.  
            4. def run():

            5. if(CheckVar1.get()==0 and CheckVar2.get()==0 and CheckVar3.get()==0 and CheckVar4.get()==0):

            6. s = '您还没选择任何爱好项目'

            7. else:

            8. s1 = "足球" if CheckVar1.get()==1 else ""

            9. s2 = "篮球" if CheckVar2.get() == 1 else ""

            10. s3 = "游泳" if CheckVar3.get() == 1 else ""

            11. s4 = "田径" if CheckVar4.get() == 1 else ""

            12. s = "您选择了%s %s %s %s" % (s1,s2,s3,s4)

            13. lb2.config(text=s)

            14.  
            15. root = tkinter.Tk()

            16. root.title('复选框')

            17. lb1=Label(root,text='请选择您的爱好项目')

            18. lb1.pack()

            19.  
            20. CheckVar1 = IntVar()

            21. CheckVar2 = IntVar()

            22. CheckVar3 = IntVar()

            23. CheckVar4 = IntVar()

            24.  
            25. ch1 = Checkbutton(root,text='足球',variable = CheckVar1,onvalue=1,offvalue=0)

            26. ch2 = Checkbutton(root,text='篮球',variable = CheckVar2,onvalue=1,offvalue=0)

            27. ch3 = Checkbutton(root,text='游泳',variable = CheckVar3,onvalue=1,offvalue=0)

            28. ch4 = Checkbutton(root,text='田径',variable = CheckVar4,onvalue=1,offvalue=0)

            29.  
            30. ch1.pack()

            31. ch2.pack()

            32. ch3.pack()

            33. ch4.pack()

            34.  
            35. btn = Button(root,text="OK",command=run)

            36. btn.pack()

            37.  
            38. lb2 = Label(root,text='')

            39. lb2.pack()

            40. root.mainloop()

      • 3.5、列表框 与 组合框

        方法功能描述
        curselection()返回光标选中项目编号的元组,注意并不是单个的整数
        delete(起始位置,终止位置)删除项目,终止位置可省略,全部清空为delete(0,END)
        get(起始位置,终止位)返回范围所含项目文本的元组,终止位置可忽略
        insert(位置,项目元素)插入项目元素(若有多项,可用列表或元组类型赋值),若位置为END,则将项目元素添加在最后
        size()返回列表框行数

        执行自定义函数时,通常使用“实例名.surselection()” 或 “selected” 来获取选中项的位置索引。由于列表框实质上就是将Python 的列表类型数据可视化呈现,在程序实现时,也可直接对相关列表数据进行操作,然后再通过列表框展示出来,而不必拘泥于可视化控件的方法。看下面的一个例子:实现列表框的初始化、添加、插入、修改、删除和清空操作,如下:

        列表框的应用

         

         
        1. from tkinter import *

        2. def ini():

        3. Lstbox1.delete(0,END)

        4. list_items = ["数学","物理","化学","语文","外语"]

        5. for item in list_items:

        6. Lstbox1.insert(END,item)

        7.  
        8. def clear():

        9. Lstbox1.delete(0,END)

        10.  
        11. def ins():

        12. if entry.get() != '':

        13. if Lstbox1.curselection() == ():

        14. Lstbox1.insert(Lstbox1.size(),entry.get())

        15. else:

        16. Lstbox1.insert(Lstbox1.curselection(),entry.get())

        17.  
        18. def updt():

        19. if entry.get() != '' and Lstbox1.curselection() != ():

        20. selected=Lstbox1.curselection()[0]

        21. Lstbox1.delete(selected)

        22. Lstbox1.insert(selected,entry.get())

        23.  
        24. def delt():

        25. if Lstbox1.curselection() != ():

        26. Lstbox1.delete(Lstbox1.curselection())

        27.  
        28. root = Tk()

        29. root.title('列表框实验')

        30. root.geometry('320x240')

        31.  
        32. frame1 = Frame(root,relief=RAISED)

        33. frame1.place(relx=0.0)

        34.  
        35. frame2 = Frame(root,relief=GROOVE)

        36. frame2.place(relx=0.5)

        37.  
        38. Lstbox1 = Listbox(frame1)

        39. Lstbox1.pack()

        40.  
        41. entry = Entry(frame2)

        42. entry.pack()

        43.  
        44. btn1 = Button(frame2,text='初始化',command=ini)

        45. btn1.pack(fill=X)

        46.  
        47. btn2 = Button(frame2,text='添加',command=ins)

        48. btn2.pack(fill=X)

        49.  
        50. btn3 = Button(frame2,text='插入',command=ins) # 添加和插入功能实质上是一样的

        51. btn3.pack(fill=X)

        52.  
        53. btn4 = Button(frame2,text='修改',command=updt)

        54. btn4.pack(fill=X)

        55.  
        56. btn5 = Button(frame2,text='删除',command=delt)

        57. btn5.pack(fill=X)

        58.  
        59. btn6 = Button(frame2,text='清空',command=clear)

        60. btn6.pack(fill=X)

        61.  
        62. root.mainloop()

        • 3.5.1、列表框:(Listbox) 可供用户单选或多选所列条目以形成人机交互。列表框控件的主要方法见下面的表:
        • 3.5.2、组合框:(Combobox) 实质上是带文本框的上拉列表框,其功能也将是Python 的列表类型数据可视化呈现,并提供用户单选或多选所列条目以形成人机交互。在图形化界面设计时,由于其具有灵活的界面,因此往往比列表框更受喜爱。但该控件并不包含在 tkinter 模块中,而是与 TreeView、Progressbar、Separator等控件一同包含在tkinter 的子模块ttk中。如果使用该控件,应先与from tkinter import ttk 语句引用ttk子模块,然后创建组合框实例: 实例名=Combobox(根对象,[属性列表])
          指定变量var=StringVar(),并设置实例属性 textvariable = var,values=[列表...]。组合框控件常用方法有:获得所选中的选项值get()和获得所选中的选项索引current()。
          看下面的一个例子:实现四则运算计算器,将两个操作数分别填入两个文本框后,通过选择组合框中的算法触发运算,如下:

          组合框的应用

           

           
          1. from tkinter.ttk import *

          2.  
          3. def calc(event):

          4. a = float(t1.get())

          5. b = float(t2.get())

          6. dic = {0:a+b,1:a-b,2:a*b,3:a/b}

          7. c = dic[comb.current()]

          8. lbl.config(text=str(c))

          9.  
          10. root = Tk()

          11. root.title('四则运算')

          12. root.geometry('320x240')

          13.  
          14. t1 = Entry(root)

          15. t1.place(relx=0.1,rely=0.1,relwidth=0.2,relheight=0.1)

          16.  
          17. t2 = Entry(root)

          18. t2.place(relx=0.5,rely=0.1,relwidth=0.2,relheight=0.1)

          19.  
          20. var = StringVar()

          21.  
          22. comb = Combobox(root,textvariable=var,values=['加','减','乘','除',])

          23. comb.place(relx=0.1,rely=0.5,relwidth=0.2)

          24. comb.bind('<<ComboboxSelected>>',calc)

          25.  
          26. lbl=Label(root,text='结果')

          27. lbl.place(relx=0.5,rely=0.7,relwidth=0.2,relheight=0.3)

          28.  
          29. root.mainloop()

      • 3.6、滑块:(Scale) 是一种 直观地进行数值输入的交互控件,其主要属性见下表:

        属性功能描述
        from_起始值(最小可取值)
        lable标签文字,默认为无
        length滑块控件实例宽(水平方向)或 高(垂直方向),默认为100像素
        orient滑块控件实例呈现方向,VERTCAL或HORIZONTAL(默认)
        repeatdelay鼠标响应延时,默认为 300ms
        resolution分辨精度,即最小值间隔
        sliderlength滑块宽度,默认为30 像素
        state状态,若设置 state=DISABLED,则滑块控件实例不可用
        tickinterval标尺间隔,默认为0,若设置过小,则会重叠
        to终止值(最大可取值)
        variable返回数值类型,可为IntVar(整数)、DoubleVar(浮点数)、或 StringVar(字符串)
        width控件实例本身的宽度,默认为15像素

        滑块控件实例的主要方法比较简单,有 get()和set(值),分别为取值和将滑块设在某特定值上。滑块实例也可绑定鼠标左键释放事件<ButtoonRelease-1>,并在执行函数中添加参数event来实现事件响应。
        例如:在一个窗体上设计一个200像素宽的水平滑块,取值范围为1.0~5.0,分辨精度为0.05,刻度间隔为 1,用鼠标拖动滑块后释放鼠标可读取滑块值并显示在标签上。效果如下:

         

        滑块控件的应用

         
        1. from tkinter import *

        2.  
        3. def show(event):

        4. s = '滑块的取值为' + str(var.get())

        5. lb.config(text=s)

        6.  
        7. root = Tk()

        8. root.title('滑块实验')

        9. root.geometry('320x180')

        10. var=DoubleVar()

        11. scl = Scale(root,orient=HORIZONTAL,length=200,from_=1.0,to=5.0,label='请拖动滑块',tickinterval=1,resolution=0.05,variable=var)

        12. scl.bind('<ButtonRelease-1>',show)

        13. scl.pack()

        14.  
        15. lb = Label(root,text='')

        16. lb.pack()

        17.  
        18. root.mainloop()

      • 3.7、菜单:(Menu)用于可视化地为一系列的命令分组,从而方便用户找到和触发执行这些命令。这里Menu所实例化别的主要是菜单,其通式为:

         
        1. 菜单实例名=Menu(根窗体)

        2. 菜单分组1=Menu(菜单实例名)

        3. 菜单实例名.add_cascade(<label=菜单分组1 显示文本>,<menu=菜单分组1>)

        4. 菜单分组1.add_command(<label=命令1文本>,<command=命令1函数名>)

        其中较为常见的方法有:add_cascade()、add_command()和add_separator(),分别用于添加一个菜单分组、添加一条菜单命令和添加一条分割线
        利用Menu控件也可以创建快捷菜单(又称为上下文菜单)。通常需要右击弹出的控件实例绑定鼠标右击响应事件<Button-3>,并指向一个捕获event参数的自定义函数,在该自定义函数中,将鼠标的触发位置event.x_root 和 event.y_root以post()方法传给菜单。
        例子:仿照window自带的“记事本”中的文件和编辑 菜单,实现在主菜单个快捷菜单上触发菜单命令,并相应改变窗体上的标签的文本内容。效果如下:

        菜单和快捷菜单

         

         
        1. from tkinter import *

        2.  
        3. def new():

        4. s = '新建'

        5. lb1.config(text=s)

        6.  
        7. def ope():

        8. s = '打开'

        9. lb1.config(text=s)

        10.  
        11. def sav():

        12. s = '保存'

        13. lb1.config(text=s)

        14.  
        15. def cut():

        16. s = '剪切'

        17. lb1.config(text=s)

        18.  
        19. def cop():

        20. s = '复制'

        21. lb1.config(text=s)

        22.  
        23. def pas():

        24. s = '粘贴'

        25. lb1.config(text=s)

        26.  
        27. def popupmenu(event):

        28. mainmenu.post(event.x_root,event.y_root)

        29.  
        30. root = Tk()

        31. root.title('菜单实验')

        32. root.geometry('320x240')

        33.  
        34. lb1 = Label(root,text='显示信息',font=('黑体',32,'bold'))

        35. lb1.place(relx=0.2,rely=0.2)

        36.  
        37. mainmenu = Menu(root)

        38. menuFile = Menu(mainmenu) # 菜单分组 menuFile

        39. mainmenu.add_cascade(label="文件",menu=menuFile)

        40. menuFile.add_command(label="新建",command=new)

        41. menuFile.add_command(label="打开",command=ope)

        42. menuFile.add_command(label="保存",command=sav)

        43. menuFile.add_separator() # 分割线

        44. menuFile.add_command(label="退出",command=root.destroy)

        45.  
        46. menuEdit = Menu(mainmenu) # 菜单分组 menuEdit

        47. mainmenu.add_cascade(label="编辑",menu=menuEdit)

        48. menuEdit.add_command(label="剪切",command=cut)

        49. menuEdit.add_command(label="复制",command=cop())

        50. menuEdit.add_command(label="粘贴",command=pas())

        51.  
        52. root.config(menu=mainmenu)

        53. root.bind('Button-3',popupmenu) # 根窗体绑定鼠标右击响应事件

        54. root.mainloop()

      • 3.8、子窗体:用Toplevel可新建一个显示在最前面的子窗体,其通式为: 字体实例名=Toplevel(根窗体),子窗体与根窗体类似,也可设置title、geomerty等属性,并在画布上布局其他控件。如下的例子:在根窗体上创建菜单,触发创建一个新的窗体

        根窗体与子窗体

         

         
        1. from tkinter import *

        2.  
        3. def newwind():

        4. winNew = Toplevel(root)

        5. winNew.geometry('320x240')

        6. winNew.title('新窗体')

        7. lb2 = Label(winNew,text='我在新窗体上')

        8. lb2.place(relx=0.2,rely=0.2)

        9. btClose=Button(winNew,text='关闭',command=winNew.destroy)

        10. btClose.place(relx=0.7,rely=0.5)

        11.  
        12. root = Tk()

        13. root.title('新建窗体实验')

        14. root.geometry('320x240')

        15.  
        16. lb1 = Label(root,text='主窗体',font=('黑体',32,'bold'))

        17. lb1.place(relx=0.2,rely=0.2)

        18.  
        19. mainmenu = Menu(root)

        20. menuFile = Menu(mainmenu)

        21. mainmenu.add_cascade(label='菜单',menu=menuFile)

        22. menuFile.add_command(label='新窗体',command=newwind)

        23. menuFile.add_separator()

        24. menuFile.add_command(label='退出',command=root.destroy)

        25.  
        26. root.config(menu=mainmenu)

        27. root.mainloop()

        关闭窗体程序运行的方法通常用 destory(),而不建议用 quit()。用Toplevel 所创建的子窗体是非模式(Modeless)的窗体,虽然初建时子窗体在最前面,但根窗体上的控件实例也是可以被操作的。

      • 3.9、模式对话框(Modal):是相对于前面介绍的非模式窗体而言的,所弹出的对话框必须应答,在关闭之前无法操作其后面的其他窗体。常见的模式对话框有消息对话框、输入对话框、文件选择对话框、颜色选择对话框等。

        • 3.9.1、交互对话框

          (一)、消息对话框: 引用 tkinter.messagebox 包,可使用消息对话框函数。执行这些函数,可弹出模式消息对话框,并根据用户的响应但会一个布尔值。其通式为:

           消息对话框函数(<title=标题文本>,<message=消息文本>,[其他参数])
          

          看下面的例子:单击按钮,弹出确认取消对话框,并将用户回答显示在标签中。效果如下:

           

          确定取消对话框

           
          1. from tkinter import *

          2. import tkinter.messagebox

          3.  
          4. def xz():

          5. answer=tkinter.messagebox.askokcancel('请选择','请选择确定或取消')

          6. if answer:

          7. lb.config(text='已确认')

          8. else:

          9. lb.config(text='已取消')

          10.  
          11. root = Tk()

          12.  
          13. lb = Label(root,text='')

          14. lb.pack()

          15. btn=Button(root,text='弹出对话框',command=xz)

          16. btn.pack()

          17. root.mainloop()

          (二)、输入对话框: 引用tkinter.simpledialog包,可弹出输入对话框,用以接收用户的简单输入。输入对话框常用 askstring()、askfloat()和askfloat() 三种函数,分别用于接收字符串、整数和浮点数类型的输入。
          如下面的例子:单击按钮,弹出输入对话框,接收文本输入显示在窗体的标签上。如下:

          输入对话框

           

           
          1. from tkinter.simpledialog import *

          2.  
          3. def xz():

          4. s=askstring('请输入','请输入一串文字')

          5. lb.config(text=s)

          6.  
          7. root = Tk()

          8.  
          9. lb = Label(root,text='')

          10. lb.pack()

          11. btn=Button(root,text='弹出输入对话框',command=xz)

          12. btn.pack()

          13. root.mainloop()

        • 3.9.2、文件选择对话框:引用tkinter.filedialog包,可弹出文件选择对话框,让用户直观地选择一个或一组文件,以供进一步的文件操作。常用的文件选择对话框函数有 askopenfilename()、askopenfilenames()和asksaveasfilename(),分别用于进一步打开一个文件、一组文件和保存文件。其中,askopenfilename()和asksaveasfilenamme()函数的返回值类型为包含文件路径的文件名字符串,而askopenfilenames()函数的返回值类型为元组。
          例如:单击按钮,弹出文件选择对话框(“打开”对话框),并将用户所选择的文件路径和文件名显示在窗体的标签上。如下

          文件选择对话框

           

           
          1. from tkinter import *

          2. import tkinter.filedialog

          3.  
          4. def xz():

          5. filename=tkinter.filedialog.askopenfilename()

          6. if filename != '':

          7. lb.config(text='您选择的文件是'+filename)

          8. else:

          9. lb.config(text='您没有选择任何文件')

          10.  
          11. root = Tk()

          12.  
          13. lb = Label(root,text='')

          14. lb.pack()

          15. btn=Button(root,text='弹出文件选择对话框',command=xz)

          16. btn.pack()

          17. root.mainloop()

        • 3.9.3、颜色选择对话框:引用tkinter.colorchooser包,可使用 askcolor()函数弹出模式颜色选择对话框,让用户可以个性化地设置颜色属性。该函数的返回形式为包含RGB十进制浮点元组和RGB十六进制字符串的元组类型,例如:“((135.527343.52734375,167.65234375,186.7265625)),'#87a7ba'”。通常,可将其转换为字符串类型后,再截取以十六进制数表示的RGB颜色字符串用于为属性赋值。
          举例:单击按钮,弹出颜色选择对话框,并将用户所选择的颜色设置为窗体上标签的背景颜色,如下:

          颜色选择对话框

           

           
          1. from tkinter import *

          2. import tkinter.colorchooser

          3.  
          4. def xz():

          5. color=tkinter.colorchooser.askcolor()

          6. colorstr=str(color)

          7. print('打印字符串%s 切掉后=%s' % (colorstr,colorstr[-9:-2]))

          8. lb.config(text=colorstr[-9:-2],background=colorstr[-9:-2])

          9.  
          10. root = Tk()

          11.  
          12. lb = Label(root,text='请关注颜色的变化')

          13. lb.pack()

          14. btn=Button(root,text='弹出颜色选择对话框',command=xz)

          15. btn.pack()

          16. root.mainloop()

    4、事件响应

    用tkinter 可将用户事件与自定义函数绑定,用键盘或鼠标的动作事件来响应触发自定义函数的执行。其通式为:

     
    1. 控件实例.bind(<事件代码>,<函数名>)

    2.  

    其中,事件代码通常以半角小于号“<”和大于号“>” 界定,包括事件和按键等 2~3个部分,它们之间用减号分隔,常见事件代码见下表:

    事件事件代码备注
    单击鼠标左键<ButtonPress-1>可简写为<Button-1> 或 <1>
    单击鼠标中键<ButtonPress-2>可简写为<Button-2> 或 <2>
    单击鼠标右键<ButtonPress-3>可简写为<Button-3> 或 <3>
    释放鼠标左键<ButtonRelease-1>---
    释放鼠标中键<ButtonRelease-2>---
    释放鼠标右键<ButtonRelease-3>---
    按住鼠标左键移动<B1-Motion>---
    按住鼠标中键移动<B2-Motion>---
    按住鼠标右键移动<B3-Motion>---
    转动鼠标滚轮<MouseWheel>---
    双击鼠标左键<Double-Button-1>---
    鼠标进入控件实例<Enter>注意与回车事件的区别
    鼠标离开控件实例<Leave>---
    键盘任意键<Key>---
    字母和数字< Key-字母>,例如<key-a>、<Key-A>简写不带小于和大于号,例如:a,A和1等
    回车<Return><Tab>,<Shift>,<Control>(注意不能用<Ctrl>),<Alt>等类同
    空格<Space>---
    方向键<Up> ,<Down>,<Left>,<Right>---
    功能键<Fn>例如:<F1>等---
    组合键键名之间以减号链接,例如<Control-k>,<Shift-6>,<Alt-Up>等注意大小写

    例如,将框架控件实例frame 绑定鼠标右键单击事件,调用自定义函数 myfunc()可表示为"frame.bind('<Button-3>',myfunc)",注意: myfunc后面没有括号。将控件实例绑定到键盘事件和部分光标不落在具体控件实例上的鼠标事件时,还需要设置该实例执行focus_set() 方法获得焦点,才能对事件持续响应。例如: frame.focus_set()。所调用的自定义函数若需要利用鼠标或键盘的响应值,可将event作为参数,通过event的属性获取。event的属性见下表:

    event属性意义
    x或y(注意是小写)相对于事件绑定控件实例左上角的坐标值(像素)
    root_x或root_y(注意是小写)相对于显示屏幕左上角的坐标值(像素)
    char可显示的字符,若按键不可显示,则返回为空字符串
    keysysm字符或字符型按键名,如:“a”或“Escape”
    keysysm_num按键的十进制 ASCII 码值

    例如:将标签绑定键盘任意键触发事件并获取焦点,并将按键字符显示在标签上

     

    响应键盘事件

     
    1. from tkinter import *

    2.  
    3. def show(event):

    4. s=event.keysym

    5. lb.config(text=s)

    6.  
    7. root=Tk()

    8. root.title('按键实验')

    9. root.geometry('200x200')

    10. lb=Label(root,text='请按键',font=('黑体',48))

    11. lb.bind('<Key>',show)

    12. lb.focus_set()

    13. lb.pack()

    14. root.mainloop()

     

     

    展开全文
  • CentOS7没有图形化界面,怎么安装图形化界面

    万次阅读 多人点赞 2020-09-27 11:49:37
    我们在安装CentOS7时,如果选择 “最小化” 安装那么系统就只有命令行界面,但是没有图形化界面,如下图: 解决的完整步骤如下: 1)开启CentOS7并登录root用户(一定要以root用户登录,其他普通用户的权限不够),...

    我们在安装CentOS7时,如果选择 “最小化” 安装那么系统就只有命令行界面,但是没有图形化界面,如下图:
    在这里插入图片描述
    解决的完整步骤如下:
    1)开启CentOS7并登录root用户(一定要以root用户登录,其他普通用户的权限不够),其中localhost login为root,Password为root用户的密码。

    2)配置网络网卡,确保与外网连通(不连通则后面的操作都无法进行):
    在命令行界面中输入命令 cd /etc/sysconfig/network-scripts/ 进入 network-scripts 目录,再输入 ls 查看network-scripts 目录下有哪些目录,此时我们会看到一个文件名为 ifcfg-ens33 的文件,如下图:
    在这里插入图片描述
    接着输入命令 vi ifcfg-ens33 打开网络配置文件,按 i 键进入编辑输入模式,在文件末尾加上如下图的内容:
    在这里插入图片描述
    之后按【ESC】键退出编辑模式,然后输入命令 :wq 保存并退出该网络配置文件,然后一定要重新加载一下网络配置文件,因为只有重新加载之后我们刚刚所做的配置才会生效,输入的重新加载网络配置文件的命令为 service network restart ,如下图:

    在这里插入图片描述
    此时配置完毕,检验一下是否可以上外网,输入命令 ping -c 3 www.baidu.com ,如下图:

    在这里插入图片描述
    成功ping通,证明第二步的配置成功了。

    3)安装图形界面GNOME的程序包:
    先输入 yum 检查yum是否可正常使用,如下图就是可以使用的:

    在这里插入图片描述
    接着输入命令 yum grouplist 列出本系统支持的图形化界面有哪些,支持很多中图形化界面,我们选择默认的图形化界面(GNOME Desktop),如下图:
    在这里插入图片描述
    接着输入命令 yum groupinstall "GNOME Desktop" "Graphical Administration Tools" 获取并安装CentOS默认的图形界面GNOME程序包,(大小写不能改,Linux是严格区分大小写的)。

    安装过程中,会有提示类似"… is ok?(y/b/n)",直接选择y,回车。然后等待自动安装(我自己装的时候因为网速比较差,大约需要十几分钟),一直到提示"Completed!",表示已经安装GNOME程序包完成,如下图:

    在这里插入图片描述
    4)修改CentOS7默认启动模式为图形化模式:
    输入命令 systemctl get-default 可查看当前默认的模式为 multi-user.target,即命令行模式,我们要将它修改为图形界面模式,如下图:
    在这里插入图片描述
    此时再次输入命令 systemctl get-default 即可查看当前修改后的默认模式为graphical.target,即图形界面模式,如下图:

    在这里插入图片描述
    5)重启CentOS,检验GUI界面效果:
    输入命令 reboot 重启CentOS系统,重启之后就已经切换到GUI图形界面模式,如下图:
    在这里插入图片描述
    登录进入系统,此时看到CentOS的桌面,如下图:
    在这里插入图片描述
    以上从命令行到图形化界面的所有操作就完成了。

    展开全文
  • Java 图形化界面的实现

    千次阅读 2020-11-10 22:44:22
    Java 图形化界面的实现 1.图形化界面实现所需的条件 图形化界面的窗体,图形化界面的面板 2.界面的窗体 2.1 什么是图形化界面的窗体 如图,黑色的外边框就类似于图形化界面的窗体,要实现图形化界面,窗体是不可...

    Java 图形化界面的实现

    1.图形化界面实现所需的条件

          图形化界面的窗体,图形化界面的面板

    2.界面的窗体

       2.1 什么是图形化界面的窗体

             如图,黑色的外边框就类似于图形化界面的窗体,要实现图形化界面,窗体是不可少的,或许有人会问只要外边框就可以了吗?当然是不可以的,还需要面板,要不然只有了外边框,里面啥也没有,那图形化界面还能称之为图形化界面.

       2.1 如何在Java 程序中实现图形化界面的窗体

             我们都知道Java 的有一个特点就是万物皆可调用

             2.1.1 Java中的窗体类

                      在Java所有类中,有一个类可以实现图形化界面的窗体,继承都有所了解吧,子类继承父类,继承父类声明的所有公共方法和属性

                      JFrame类是Java中的窗体类,我们现在声明一个类,去继承JFrame.

             2.1.2 自定义窗体类的步骤

                      1.写一个类继承于JFrame

                      2.写一个构造方法,初始化窗体的属性

             2.1.3 实现自定义窗体类

                        例如:

    import javax.swing.JFrame;
    //写一个类继承于 JFrame 
    public class Frame extends JFrame{
        //构造方法
        public Frame(){
        //设置窗体的标题  来源于JFrame setTitle(标题);
            setTitle("图形化界面");
        //设置窗体的大小    setSize(宽度,高度);
            setSize(512,726);
        //设置窗体的位置 设置位置居中显示  setLocationRelativeTo(null);
            setLocationRelativeTo(null);
        //如果不想改变窗口的大小 setResizable(false);
            setResizable(false);
        //窗口关闭后所打开的程序并没有关闭,会大大影响运行内存,所以我们可以每次关闭的时候关闭程序
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //运行
            public static void main(String args[]){
                //创建Frame的对象
                Frame frame = new Frame();
                //显示窗口    true 是显示窗口,false 是隐藏窗口
                frame.setVisible(true);
            }
        }
    }

     结果

    3.图形化界面的面板

       3.1 什么是图像化界面的面板

              

    图形化界面的面板就是黑色外边框以内的红色的部分,要实现图像化界面,面板也是不可或缺的一部分.和窗体一样重要,缺一不可!

        3.2 Java 中的面板类

              在Java所有类中,有一个类可以实现图形化界面的面板,继承都有所了解吧,子类继承父类,继承父类声明的所有公共方法和属性

               JPanel类是Java中的窗体类,我们现在声明一个类,去继承JPanel.

        3.3 自定义面板的步骤

              1.创建一个类继承 JPanel 

              2.创建一个构造方法,初始化(确定)面板的属性

        3.4实现自定义面板类

        添加背景颜色

    import java.awt.Color;
    import javax.swing.JPanel;
    //创建一个类去继承Jpanel
    public class Panel extends JPanel{
        //构造方法
        public Panel{
            //设置背景的颜色
            setBackground(Color.pink);
        }
    }

       添加背景图片    添加背景图片需要一个 APP的类 

    import java.awt.image.BufferedImage;
    public class App{
        /**
           BufferedImage  Java 中用来表示图片类
           @param path 图片的路径
        */
        public static BufferedImage getImage(String path){
        // Java 中的IO流,输送数据的管道
        // 输入输出流
        // App.class  ,找到App类的路径(用到了反射的知识)
        // getResource()  获取资源
        try{
            BufferedImage img = ImageIO.read(App.class.getResource(path));
            //如果找到图片,就将图片返回
            return img;
        }catch(IOException e){
            // catch 如果找不到图片,就会捕获找不到图片的原因
            e.printStackTrace();
        }
            return null;
        }
    }

    添加背景图片

    import java.awt.Color;
    import javax.swing.JPanel;
    //创建一个类去继承Jpanel
    public class Panel extends JPanel{
        //1.定义背景图
        BufferedImage bg;
        //构造方法
        public Panel{
            //设置背景的颜色
            setBackground(Color.pink);
            //初始化图片
            bg = App.getImage(图片在哪个路径 如:"/image/1.png");
            //重写Paint 方法
            @override
            public void paint(Graphics g){
            super.paint(g);
            //调用 方法 g.drawImage(),确定图片的坐标, 如 g.drawImage(图片, 图片的横坐标,图片的纵坐标,图片的宽,图片的高,null);
            g.drawImage(bg,0,0,512,726,null);
            }
        }
    }

      面板要实现,将他加到窗体中

    import javax.swing.JFrame;
    //写一个类继承于 JFrame 
    public class Frame extends JFrame{
        //构造方法
        public Frame(){
        //设置窗体的标题  来源于JFrame setTitle(标题);
            setTitle("图形化界面");
        //设置窗体的大小    setSize(宽度,高度);
            setSize(512,726);
        //设置窗体的位置 设置位置居中显示  setLocationRelativeTo(null);
            setLocationRelativeTo(null);
        //如果不想改变窗口的大小 setResizable(false);
            setResizable(false);
        //窗口关闭后所打开的程序并没有关闭,会大大影响运行内存,所以我们可以每次关闭的时候关闭程序
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //运行
            public static void main(String args[]){
                //创建Frame的对象
                Frame frame = new Frame();
                //创建Panel 对象
                Panel panel = new Panel();
                //显示窗口    true 是显示窗口,false 是隐藏窗口
                frame.setVisible(true);
                //将面板添加到JPrame
                frame.add(panel);
            }
        }
    }

    注:窗体和面板是一起的是不可分的

    结果

    面板的的优化下次在详细戏说!

    展开全文
  • Linux命令行安装图形化界面

    千次阅读 2021-01-27 08:59:58
    Linux命令行安装图形化界面 作者:刘国凯 ## 最小化安装 Linux安装向导界面,在"软件选择"中选择"最小安装" {#linux安装向导界面在软件选择中选择最小安装 .list-paragraph} 安装完成后重启,进入命令行界面 ...
  • Linux 安装图形化界面

    千次阅读 2019-08-03 14:27:13
    图形化界面和命令行界面进行切换图形-命令:ctr+alt+F2 命令-图形:startx 卸载图行界面 sudo yum groupremove “GNOME Desktop” “Graphical Administration Tools” 使用service脚本来调度网络服务,如: ...
  • Ubuntu安装图形化界面

    千次阅读 2021-07-13 15:26:08
    文章目录第一步:更新apt-get的仓库和包的列表第二步:下载tasksel工具第三步:下载显示管理器第四步:下载图形化界面参考链接 第一步:更新apt-get的仓库和包的列表 sudo apt-get update && sudo apt-get ...
  • CentOS7开启与关闭图形化界面

    千次阅读 2021-02-23 14:47:30
    一般在服务器中我们安装CentOS系统时都会最小化安装以保证性能最大化,某些情况下我们拿到的系统默认装好了图形化界面图形化界面会消耗一定的系统资源,如果没办法重装系统时,我们可以选择将图形化界面关闭以节省...
  • linux安装图形化界面 1、查看电脑是否联网 1.1、输入命令 ping www.baidu.com 没有返回字节的就是没有联网。 如果未联网进行1.2,如果已经联网请进行2即可,因为我在安装的时候已经把网络打开了,所以我的是已经...
  • centos7安装图形化界面图文详解

    万次阅读 多人点赞 2019-09-05 11:03:00
    centos7没有图形化操作可能对很多人来说都不太习惯,下面我们来为centos7安装图形化界面,本文以安装 GNOME 图形化为例 写在安装前: 如果你的centos7是最小化安装的那默认都是不带X WINDOWS的,那在安装图形化界面...
  • Linux 安装图形化界面(GUI)

    千次阅读 2021-09-09 21:44:14
    配置 vnc 远程桌面可以参考:Linux 配置 VNC 远程桌面 使用 vnc 等工具连接通常显示如下: 也就是无法使用图形化界面,可以通过 yum 直接安装图形化界面: Linux 6: yum groupinstall -y "X Window System" yum ...
  • 图形化界面扫雷(C语言+easyx实现,多图教学)

    千次阅读 多人点赞 2021-11-07 22:41:37
    扫雷前言准备工作EasyX的下载一些准备知识头文件的引用图形化界面的创建图形化界面简介鼠标操作提示框 前言 学了那么长时间的C语言,我们所有的一切似乎都被禁锢在黑框框(控制台)里,让人觉得很无趣,学习unity...
  • 此软件可快速打开mysql而不必去搜索mysql的具体位置
  • 虚拟机Linux安装图形化界面

    千次阅读 2021-04-27 23:09:31
    红帽命令行运行图形界面 1.登录虚拟机 2.挂载光盘 命令: 1.挂载光盘到/mnt/目录下。 mount /dev/cdrom /mnt/ 2. 创建opt/package/目录。 mkdir /opt/package/ 3.将mnt目录下的所有文件拷贝到/opt/RH/。 cp -rf /...
  • 阿里云Ubantu16.04配置图形化界面

    千次阅读 2019-07-10 20:23:49
    阿里云Ubantu16.04配置图形化界面 新手接触服务器,有个图形化界面才舒服(其实就是想要个跟windows一样的图像操作界面哈哈),不懂的有很多,望谅解哈~ 一、阿里云官网购买云服务器 ​ ·首先作为新手,选择购买入门...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 377,989
精华内容 151,195
关键字:

图形化界面