精华内容
下载资源
问答
  • 本文实例讲述了C#实现WinForm禁止最大化、最小化、双击标题栏、双击图标等操作的方法。分享给大家供大家参考。具体实现方法如下: protected override void WndProc(ref Message m) { if (m.Msg

    from:http://www.jb51.net/article/71319.htm

    本文实例讲述了C#实现WinForm禁止最大化、最小化、双击标题栏、双击图标等操作的方法。分享给大家供大家参考。具体实现方法如下:

            protected override void WndProc(ref Message m)
            {
                if (m.Msg == 0x112)
                {
                    switch ((int)m.WParam)
                    {
                        //禁止双击标题栏关闭窗体
                        case 0xF063:
                        case 0xF093:
                            m.WParam = IntPtr.Zero;
                            break;
                        //禁止拖拽标题栏还原窗体
                        case 0xF012:
                        case 0xF010:
                            m.WParam = IntPtr.Zero;
                            break;
                        //禁止双击标题栏
                        case 0xf122:
                            m.WParam = IntPtr.Zero;
                            break;
                        //禁止关闭按钮
                        case 0xF060:
                            m.WParam = IntPtr.Zero;
                            break;
                        //禁止最大化按钮
                        case 0xf020:
                            m.WParam = IntPtr.Zero;
                            break;
                        //禁止最小化按钮
                        case 0xf030:
                            m.WParam = IntPtr.Zero;
                            break;
                        //禁止还原按钮
                        case 0xf120:
                            m.WParam = IntPtr.Zero;
                            break;
                    }
                }
                base.WndProc(ref m);
            }


    展开全文
  • if (this.WindowState == System.Windows.WindowState.Normal) { this.imgMax.Source = new BitmapImage(new Uri("Image/recover2.png", UriKind.Relative)); this.WindowState = System.Windows.WindowState....

    App.xaml代码:

    <Application x:Class="WpfToolbar.App"
                 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                 xmlns:local="clr-namespace:WpfToolbar"
                 StartupUri="MainWindow.xaml">
        <Application.Resources>
            <ResourceDictionary>
                <Style x:Key="WindowStyle" TargetType="{x:Type Window}">
                    <Setter Property="WindowChrome.WindowChrome">
                        <Setter.Value>
                            <WindowChrome CaptionHeight="30"
                                  CornerRadius="20"
                                  GlassFrameThickness="0"
                                  NonClientFrameEdges="None"
                                  ResizeBorderThickness="5"
                                  UseAeroCaptionButtons="False" />
                        </Setter.Value>
                    </Setter>
                </Style>
            </ResourceDictionary>
        </Application.Resources>
    </Application>
    

     

    MainWindow.xaml代码:

    <Window x:Class="WpfToolbar.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
            xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
            xmlns:local="clr-namespace:WpfToolbar"
            mc:Ignorable="d"
            Title="MainWindow" Height="450" Width="800"
            WindowStyle="None"
            Style="{StaticResource WindowStyle}" 
            StateChanged="Window_StateChanged">
        <Grid>
            <Grid.RowDefinitions>
                <RowDefinition Height="40" />
                <RowDefinition Height="*" />
                <RowDefinition Height="10" />
            </Grid.RowDefinitions>
            <Grid Grid.Row="0" Background="Red">
                <WrapPanel HorizontalAlignment="Right" VerticalAlignment="Center" Background="#f5f5f5"  WindowChrome.IsHitTestVisibleInChrome="True">
                    <Border x:Name="bdMin" Height="40" MouseLeftButtonUp="bdMin_MouseLeftButtonUp">
                        <Image x:Name="imgMin" Source="Image/min2.png" Cursor="Hand" Stretch="None" Width="20" Height="20" Margin="15,0"/>
                    </Border>
                     
                    <Border x:Name="bdMax" MouseLeftButtonUp="bdMax_MouseLeftButtonUp">
                        <Image x:Name="imgMax" Source="Image/max2.png"  Cursor="Hand" Stretch="None" Width="20" Height="20" Margin="15,0" />
                    </Border> 
    
                    <Border x:Name="bdClose" MouseLeftButtonUp="bdClose_MouseLeftButtonUp">
                        <Image x:Name="imgClose" Source="Image/close2.png" Cursor="Hand" Stretch="None" Width="20" Height="20" Margin="15,0" />
                    </Border>
                </WrapPanel>
            </Grid>
    
            <Grid Grid.Row="1" Background="Blue" />
            <Grid Grid.Row="2" Background="Red" />
        </Grid>
    </Window>
    

     

    MainWindow.xaml.cs代码:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Data;
    using System.Windows.Documents;
    using System.Windows.Input;
    using System.Windows.Media;
    using System.Windows.Media.Imaging;
    using System.Windows.Navigation;
    using System.Windows.Shapes;
    
    namespace WpfToolbar
    {
        /// <summary>
        /// MainWindow.xaml 的交互逻辑
        /// </summary>
        public partial class MainWindow : Window
        {
            public MainWindow()
            {
                InitializeComponent();
    
                WindowsFullScreenHelper.SetWindowFullScrreng(this);
            }
    
            private void bdMin_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
            {
                this.WindowState = WindowState.Minimized;
            }
    
            bool isExcuted = false;//点击最大化按钮时,阻止被StateChanged事件再次调用
            private void bdMax_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
            {
                isExcuted = true;
                if (this.WindowState == System.Windows.WindowState.Normal)
                {
                    this.imgMax.Source = new BitmapImage(new Uri("Image/recover2.png", UriKind.Relative));
                    this.WindowState = System.Windows.WindowState.Maximized;
                }
                else
                {
                    this.imgMax.Source = new BitmapImage(new Uri("Image/max2.png", UriKind.Relative));
                    this.WindowState = System.Windows.WindowState.Normal;
                }
                isExcuted = false;
            }  
            private void bdClose_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
            { 
                this.Close(); 
            } 
            private void Window_StateChanged(object sender, EventArgs e)
            {
                if (!isExcuted)
                {
                    if (this.WindowState == System.Windows.WindowState.Normal)
                    {
                        this.imgMax.Source = new BitmapImage(new Uri("Image/max2.png", UriKind.Relative));
                        this.WindowState = System.Windows.WindowState.Normal;
                    }
                    else if (this.WindowState == WindowState.Maximized)
                    {
                        this.imgMax.Source = new BitmapImage(new Uri("Image/recover2.png", UriKind.Relative));
                        this.WindowState = System.Windows.WindowState.Maximized;
                    }
                }
            }
        }
    }
    

     

    WindowsFullScreenHelper类代码:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Runtime.InteropServices;
    using System.Text;
    using System.Windows;
    using System.Windows.Interop;
    
    namespace WpfToolbar
    {
        public class WindowsFullScreenHelper
        {
            private static Window movewin;
            public static void SetWindowFullScrreng(Window wpfWindow)
            {
                movewin = wpfWindow;
                if (wpfWindow == null)
                {
                    return;
                }
    
                if (wpfWindow.WindowState == WindowState.Maximized)
                {
                    wpfWindow.WindowState = WindowState.Normal;
                    wpfWindow.Loaded += delegate { wpfWindow.WindowState = WindowState.Maximized; };
                }
                wpfWindow.SourceInitialized += delegate
                {
                    IntPtr handle = (new WindowInteropHelper(wpfWindow)).Handle;
                    HwndSource source = HwndSource.FromHwnd(handle);
                    if (source != null)
                    {
                        source.AddHook(WindowProc);
                    }
                };
            }
            private static IntPtr WindowProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
            {
                switch (msg)
                {
                    case 0x0024:
                        WmGetMinMaxInfo(hwnd, lParam);
                        // handled = true;
                        break;
                }
    
                return (IntPtr)0;
            }
            private static void WmGetMinMaxInfo(IntPtr hwnd, IntPtr lParam)
            {
                var mmi = (MINMAXINFO)Marshal.PtrToStructure(lParam, typeof(MINMAXINFO));
    
                // Adjust the maximized size and position to fit the work area of the correct monitor
                int MONITOR_DEFAULTTONEAREST = 0x00000002;
                IntPtr monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
                if (monitor != IntPtr.Zero)
                {
    
                    var monitorInfo = new MONITORINFO();
                    GetMonitorInfo(monitor, monitorInfo);
                    RECT rcWorkArea = monitorInfo.rcWork;
                    RECT rcMonitorArea = monitorInfo.rcMonitor;
                    mmi.ptMaxPosition.x = Math.Abs(rcWorkArea.left - rcMonitorArea.left);
                    mmi.ptMaxPosition.y = Math.Abs(rcWorkArea.top - rcMonitorArea.top);
                    mmi.ptMaxSize.x = Math.Abs(rcWorkArea.right - rcWorkArea.left);
                    mmi.ptMaxSize.y = Math.Abs(rcWorkArea.bottom - rcWorkArea.top);
                }
                Marshal.StructureToPtr(mmi, lParam, true);
    
            }
            [DllImport("user32")]
            internal static extern bool GetMonitorInfo(IntPtr hMonitor, MONITORINFO lpmi);
            /// <summary>
            /// 
            /// </summary>
            [DllImport("User32")]
            internal static extern IntPtr MonitorFromWindow(IntPtr handle, int flags);
    
            #region Nested type: MINMAXINFO
    
            [StructLayout(LayoutKind.Sequential)]
            internal struct MINMAXINFO
            {
                public POINT ptReserved;
                public POINT ptMaxSize;
                public POINT ptMaxPosition;
                public POINT ptMinTrackSize;
                public POINT ptMaxTrackSize;
            };
    
            #endregion
    
            #region Nested type: MONITORINFO
    
            /// <summary>
            /// </summary>
            [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
            internal class MONITORINFO
            {
                /// <summary>
                /// </summary>            
                public int cbSize = Marshal.SizeOf(typeof(MONITORINFO));
    
                /// <summary>
                /// </summary>            
                public RECT rcMonitor;
    
                /// <summary>
                /// </summary>            
                public RECT rcWork;
    
                /// <summary>
                /// </summary>            
                public int dwFlags;
            }
    
            #endregion
    
            #region Nested type: POINT
    
            /// <summary>
            /// POINT aka POINTAPI
            /// </summary>
            [StructLayout(LayoutKind.Sequential)]
            internal struct POINT
            {
                /// <summary>
                /// x coordinate of point.
                /// </summary>
                public int x;
    
                /// <summary>
                /// y coordinate of point.
                /// </summary>
                public int y;
    
                /// <summary>
                /// Construct a point of coordinates (x,y).
                /// </summary>
                public POINT(int x, int y)
                {
                    this.x = x;
                    this.y = y;
                }
            }
    
            #endregion
    
            #region Nested type: RECT
    
            /// <summary> Win32 </summary>
            [StructLayout(LayoutKind.Sequential, Pack = 0)]
            internal struct RECT
            {
                /// <summary> Win32 </summary>
                public int left;
    
                /// <summary> Win32 </summary>
                public int top;
    
                /// <summary> Win32 </summary>
                public int right;
    
                /// <summary> Win32 </summary>
                public int bottom;
    
                /// <summary> Win32 </summary>
                public static readonly RECT Empty;
    
                /// <summary> Win32 </summary>
                public int Width
                {
                    get { return Math.Abs(right - left); } // Abs needed for BIDI OS
                }
    
                /// <summary> Win32 </summary>
                public int Height
                {
                    get { return bottom - top; }
                }
    
                /// <summary> Win32 </summary>
                public RECT(int left, int top, int right, int bottom)
                {
                    this.left = left;
                    this.top = top;
                    this.right = right;
                    this.bottom = bottom;
                }
    
    
                /// <summary> Win32 </summary>
                public RECT(RECT rcSrc)
                {
                    left = rcSrc.left;
                    top = rcSrc.top;
                    right = rcSrc.right;
                    bottom = rcSrc.bottom;
                }
    
                /// <summary> Win32 </summary>
                public bool IsEmpty
                {
                    get
                    {
                        // BUGBUG : On Bidi OS (hebrew arabic) left > right
                        return left >= right || top >= bottom;
                    }
                }
    
                /// <summary> Return a user friendly representation of this struct </summary>
                public override string ToString()
                {
                    if (this == Empty)
                    {
                        return "RECT {Empty}";
                    }
                    return "RECT { left : " + left + " / top : " + top + " / right : " + right + " / bottom : " + bottom +
                           " }";
                }
    
                /// <summary> Determine if 2 RECT are equal (deep compare) </summary>
                public override bool Equals(object obj)
                {
                    if (!(obj is System.Windows.Rect))
                    {
                        return false;
                    }
                    return (this == (RECT)obj);
                }
    
                /// <summary>Return the HashCode for this struct (not garanteed to be unique)</summary>
                public override int GetHashCode()
                {
                    return left.GetHashCode() + top.GetHashCode() + right.GetHashCode() + bottom.GetHashCode();
                }
    
    
                /// <summary> Determine if 2 RECT are equal (deep compare)</summary>
                public static bool operator ==(RECT rect1, RECT rect2)
                {
                    return (rect1.left == rect2.left && rect1.top == rect2.top && rect1.right == rect2.right &&
                            rect1.bottom == rect2.bottom);
                }
    
                /// <summary> Determine if 2 RECT are different(deep compare)</summary>
                public static bool operator !=(RECT rect1, RECT rect2)
                {
                    return !(rect1 == rect2);
                }
            }
            #endregion
        }
    } 
    

     

    展开全文
  • Qt 之 自定义窗口标题栏

    万次阅读 多人点赞 2016-12-06 23:20:44
    今天晚上就如何用Qt自定义窗口标题栏,写了一个小例子,比较基础,实用。在此分享一下。 首先Qt是跨平台的,所以在不同的平台上窗口的外观是不一样的。比如在windows平台上,用Qt显示的一个窗口就跟一般windows程序...

    Qt技术学习班开始了,更多精彩、好玩的内容等着你,赶紧报名吧! 群号:655815739


    一、简述

    今天晚上就如何用Qt自定义窗口标题栏,写了一个小例子,比较基础,实用。在此分享一下。

    首先Qt是跨平台的,所以在不同的平台上窗口的外观是不一样的。比如在windows平台上,用Qt显示的一个窗口就跟一般windows程序窗口的外观一致,如下图。

    这里写图片描述这里写图片描述

    同时不同windows系统,窗口外观显示也不一致,上面左边是我在win8系统上显示的窗口右边是win7下显示的窗口。可以看出两个窗口外观差别很大,同时在win8系统中标题内容居中了,win7标题则靠左。为了 解决窗口外观在不同系统下不一致的问题,我们干脆去掉窗口自带的边框,Qt中直接用一下代码即可去除窗口边框效果

    this->setWindowFlags(Qt::FramelessWindowHint);

    这里写图片描述

    上图就是去除窗口边框后的效果图。这样是不是看起来奇怪,是不是没有了标题栏。

    一般情况下一个标题栏提供了窗口图标、窗口标题、最小化、最大化、关闭按钮等几个部分,这些对于一个窗口来说是十分重要的,窗口图标标志着这是一个什么程序,标题就表明这个窗口是干什么的,最小化、最大化、关闭等按钮则是用户对该窗口的操作。


    下图是QQ的几个窗口标题栏。可以看出QQ的窗口都用了同一个窗口图标,一看到这个标志就知道是QQ程序的窗口,同时每个窗口标题栏不同,代表着这个窗口的作用以及用户可以在窗口中进行什么样的操作。

    这里写图片描述


    QQ音乐的标题栏

    这里写图片描述

    有道词典的标题栏

    这里写图片描述

    PS软件的标题栏

    这里写图片描述

    以上几款软件的标题栏都涵盖了以上几个重要的组成部分。


    自定义标题栏的好处

    • 首先自定义标题栏解决了我们程序在不同平台乃至同一平台不同的版本中样式不同的问题,使用自定义标题栏,能够保证外观的一致性,这也是为什么像QQ、有道词典、360等软件都没有使用系统标题栏,都是自定义标题栏了。

    • 正是因为自定义标题栏,我们可以自定义不再受约束,想怎么设计就怎么设计。

    • 自定义标题栏可以使用自己设计的图标,当然比系统的图标要美观了,颜值当然更高了。

    下面就讲一讲如何用Qt实现自定义窗口标题栏。

    二、代码之路

    这个是之前模仿QQ做的一个登录界面窗口。

    这里写图片描述


    这里我们先看一下本程序中简单一点的效果图:

    这里写图片描述

    注意:

    本程序的BaseWindow是继承于QWidget,如果大家想要继承QMainWindow,则需要把BaseWindow的基类改为QMainWindow。


    // 标题栏类;

    mytitlebar.h

    #include <QWidget>
    #include <QLabel>
    #include <QPushButton>
    #include <QTimer>
    
    enum ButtonType
    {
        MIN_BUTTON = 0,         // 最小化和关闭按钮;
        MIN_MAX_BUTTON ,        // 最小化、最大化和关闭按钮;
        ONLY_CLOSE_BUTTON       // 只有关闭按钮;
    };
    
    class MyTitleBar : public QWidget
    {
        Q_OBJECT
    
    public:
        MyTitleBar(QWidget *parent);
        //这里parent没有给默认值NULL,保证在创建MyTitleBar对象时父指针必须得赋值;且赋值不为NULL;
        ~MyTitleBar();
    
        // 设置标题栏背景色及是否设置标题栏背景色透明;
        void setBackgroundColor(int r, int g, int b , bool isTransparent = false);
        // 设置标题栏图标;
        void setTitleIcon(QString filePath , QSize IconSize = QSize(25 , 25));
        // 设置标题内容;
        void setTitleContent(QString titleContent , int titleFontSize = 9);
        // 设置标题栏长度;
        void setTitleWidth(int width);
        // 设置标题栏上按钮类型;
        void setButtonType(ButtonType buttonType);
        // 设置标题栏中的标题是否会滚动;具体可以看效果;
        void setTitleRoll();
        // 设置窗口边框宽度;
        void setWindowBorderWidth(int borderWidth);
    
        // 保存/获取 最大化前窗口的位置及大小;
        void saveRestoreInfo(const QPoint point, const QSize size);
        void getRestoreInfo(QPoint& point, QSize& size);
    
    private:
        void paintEvent(QPaintEvent *event);
        void mouseDoubleClickEvent(QMouseEvent *event);
        void mousePressEvent(QMouseEvent *event);
        void mouseMoveEvent(QMouseEvent *event);
        void mouseReleaseEvent(QMouseEvent *event);
    
        // 初始化控件;
        void initControl();
        // 信号槽的绑定;
        void initConnections();
        // 加载样式文件;
        void loadStyleSheet(const QString &sheetName);
    
    signals:
        // 按钮触发的信号;
        void signalButtonMinClicked();
        void signalButtonRestoreClicked();
        void signalButtonMaxClicked();
        void signalButtonCloseClicked();
    
    private slots:
        // 按钮触发的槽;
        void onButtonMinClicked();
        void onButtonRestoreClicked();
        void onButtonMaxClicked();
        void onButtonCloseClicked();
        void onRollTitle();
    
    private:
        QLabel* m_pIcon;                    // 标题栏图标;
        QLabel* m_pTitleContent;            // 标题栏内容;
        QPushButton* m_pButtonMin;          // 最小化按钮;
        QPushButton* m_pButtonRestore;      // 最大化还原按钮;
        QPushButton* m_pButtonMax;          // 最大化按钮;
        QPushButton* m_pButtonClose;        // 关闭按钮;
    
        // 标题栏背景色;
        int m_colorR;
        int m_colorG;
        int m_colorB;
    
        // 最大化,最小化变量;
        QPoint m_restorePos;
        QSize m_restoreSize;
        // 移动窗口的变量;
        bool m_isPressed;
        QPoint m_startMovePos;
        // 标题栏跑马灯效果时钟;
        QTimer m_titleRollTimer;
        // 标题栏内容;
        QString m_titleContent;
        // 按钮类型;
        ButtonType m_buttonType;
        // 窗口边框宽度;
        int m_windowBorderWidth;
        // 标题栏是否透明;
        bool m_isTransparent;
    };
    

    mytitlebar.cpp

    #include "mytitlebar.h"
    #include <QHBoxLayout>
    #include <QPainter>
    #include <QFile>
    #include <QMouseEvent>
    
    #define BUTTON_HEIGHT 30        // 按钮高度;
    #define BUTTON_WIDTH 30         // 按钮宽度;
    #define TITLE_HEIGHT 30         // 标题栏高度;
    
    MyTitleBar::MyTitleBar(QWidget *parent)
        : QWidget(parent)
        , m_colorR(153)
        , m_colorG(153)
        , m_colorB(153)
        , m_isPressed(false)
        , m_buttonType(MIN_MAX_BUTTON)
        , m_windowBorderWidth(0)
        , m_isTransparent(false)
    {
        // 初始化;
        initControl();
        initConnections();
        // 加载本地样式 MyTitle.css文件;
        loadStyleSheet("MyTitle");
    }
    
    MyTitleBar::~MyTitleBar()
    {
    
    }
    
    // 初始化控件;
    void MyTitleBar::initControl()
    {
        m_pIcon = new QLabel;
        m_pTitleContent = new QLabel;
    
        m_pButtonMin = new QPushButton;
        m_pButtonRestore = new QPushButton;
        m_pButtonMax = new QPushButton;
        m_pButtonClose = new QPushButton;
    
        m_pButtonMin->setFixedSize(QSize(BUTTON_WIDTH, BUTTON_HEIGHT));
        m_pButtonRestore->setFixedSize(QSize(BUTTON_WIDTH, BUTTON_HEIGHT));
        m_pButtonMax->setFixedSize(QSize(BUTTON_WIDTH, BUTTON_HEIGHT));
        m_pButtonClose->setFixedSize(QSize(BUTTON_WIDTH, BUTTON_HEIGHT));
    
        m_pTitleContent->setObjectName("TitleContent");
        m_pButtonMin->setObjectName("ButtonMin");
        m_pButtonRestore->setObjectName("ButtonRestore");
        m_pButtonMax->setObjectName("ButtonMax");
        m_pButtonClose->setObjectName("ButtonClose");
    
        m_pButtonMin->setToolTip(QStringLiteral("最小化"));
        m_pButtonRestore->setToolTip(QStringLiteral("还原"));
        m_pButtonMax->setToolTip(QStringLiteral("最大化"));
        m_pButtonClose->setToolTip(QStringLiteral("关闭"));
    
        QHBoxLayout* mylayout = new QHBoxLayout(this);
        mylayout->addWidget(m_pIcon);
        mylayout->addWidget(m_pTitleContent);
    
        mylayout->addWidget(m_pButtonMin);
        mylayout->addWidget(m_pButtonRestore);
        mylayout->addWidget(m_pButtonMax);
        mylayout->addWidget(m_pButtonClose);
    
        mylayout->setContentsMargins(5, 0, 0, 0);
        mylayout->setSpacing(0);
    
        m_pTitleContent->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
        this->setFixedHeight(TITLE_HEIGHT);
        this->setWindowFlags(Qt::FramelessWindowHint);
    }
    
    // 信号槽的绑定;
    void MyTitleBar::initConnections()
    {
        connect(m_pButtonMin, SIGNAL(clicked()), this, SLOT(onButtonMinClicked()));
        connect(m_pButtonRestore, SIGNAL(clicked()), this, SLOT(onButtonRestoreClicked()));
        connect(m_pButtonMax, SIGNAL(clicked()), this, SLOT(onButtonMaxClicked()));
        connect(m_pButtonClose, SIGNAL(clicked()), this, SLOT(onButtonCloseClicked()));
    }
    
    // 设置标题栏背景色,在paintEvent事件中进行绘制标题栏背景色;
    // 在构造函数中给了默认值,可以外部设置颜色值改变标题栏背景色;
    void MyTitleBar::setBackgroundColor(int r, int g, int b, bool isTransparent)
    {
        m_colorR = r;
        m_colorG = g;
        m_colorB = b;
        m_isTransparent = isTransparent;
        // 重新绘制(调用paintEvent事件);
        update();
    }
    
    // 设置标题栏图标;
    void MyTitleBar::setTitleIcon(QString filePath, QSize IconSize)
    {
        QPixmap titleIcon(filePath);
        m_pIcon->setPixmap(titleIcon.scaled(IconSize));
    }
    
    // 设置标题内容;
    void MyTitleBar::setTitleContent(QString titleContent, int titleFontSize)
    {
        // 设置标题字体大小;
        QFont font = m_pTitleContent->font();
        font.setPointSize(titleFontSize);
        m_pTitleContent->setFont(font);
        // 设置标题内容;
        m_pTitleContent->setText(titleContent);
        m_titleContent = titleContent;
    }
    
    // 设置标题栏长度;
    void MyTitleBar::setTitleWidth(int width)
    {
        this->setFixedWidth(width);
    }
    
    // 设置标题栏上按钮类型;
    // 由于不同窗口标题栏上的按钮都不一样,所以可以自定义标题栏中的按钮;
    // 这里提供了四个按钮,分别为最小化、还原、最大化、关闭按钮,如果需要其他按钮可自行添加设置;
    void MyTitleBar::setButtonType(ButtonType buttonType)
    {
        m_buttonType = buttonType;
    
        switch (buttonType)
        {
        case MIN_BUTTON:
            {
                m_pButtonRestore->setVisible(false);
                m_pButtonMax->setVisible(false);
            }
            break;
        case MIN_MAX_BUTTON:
            {
                m_pButtonRestore->setVisible(false);
            }
            break;
        case ONLY_CLOSE_BUTTON:
            {
                m_pButtonMin->setVisible(false);
                m_pButtonRestore->setVisible(false);
                m_pButtonMax->setVisible(false);
            }
            break;
        default:
            break;
        }
    }
    
    // 设置标题栏中的标题是否会自动滚动,跑马灯的效果;
    // 一般情况下标题栏中的标题内容是不滚动的,但是既然自定义就看自己需要嘛,想怎么设计就怎么搞O(∩_∩)O!
    void MyTitleBar::setTitleRoll()
    {
        connect(&m_titleRollTimer, SIGNAL(timeout()), this, SLOT(onRollTitle()));
        m_titleRollTimer.start(200);
    }
    
    // 设置窗口边框宽度;
    void MyTitleBar::setWindowBorderWidth(int borderWidth)
    {
        m_windowBorderWidth = borderWidth;
    }
    
    // 保存窗口最大化前窗口的位置以及大小;
    void MyTitleBar::saveRestoreInfo(const QPoint point, const QSize size)
    {
        m_restorePos = point;
        m_restoreSize = size;
    }
    
    // 获取窗口最大化前窗口的位置以及大小;
    void MyTitleBar::getRestoreInfo(QPoint& point, QSize& size)
    {
        point = m_restorePos;
        size = m_restoreSize;
    }
    
    // 绘制标题栏背景色;
    void MyTitleBar::paintEvent(QPaintEvent *event)
    {
        // 是否设置标题透明;
        if (!m_isTransparent)
        {
            //设置背景色;
            QPainter painter(this);
            QPainterPath pathBack;
            pathBack.setFillRule(Qt::WindingFill);
            pathBack.addRoundedRect(QRect(0, 0, this->width(), this->height()), 3, 3);
            painter.setRenderHint(QPainter::Antialiasing, true);
            painter.fillPath(pathBack, QBrush(QColor(m_colorR, m_colorG, m_colorB)));
        }   
    
        // 当窗口最大化或者还原后,窗口长度变了,标题栏的长度应当一起改变;
        // 这里减去m_windowBorderWidth ,是因为窗口可能设置了不同宽度的边框;
        // 如果窗口有边框则需要设置m_windowBorderWidth的值,否则m_windowBorderWidth默认为0;
        if (this->width() != (this->parentWidget()->width() - m_windowBorderWidth))
        {
            this->setFixedWidth(this->parentWidget()->width() - m_windowBorderWidth);
        }
        QWidget::paintEvent(event);
    }
    
    // 双击响应事件,主要是实现双击标题栏进行最大化和最小化操作;
    void MyTitleBar::mouseDoubleClickEvent(QMouseEvent *event)
    {
        // 只有存在最大化、还原按钮时双击才有效;
        if (m_buttonType == MIN_MAX_BUTTON)
        {
            // 通过最大化按钮的状态判断当前窗口是处于最大化还是原始大小状态;
            // 或者通过单独设置变量来表示当前窗口状态;
            if (m_pButtonMax->isVisible())
            {
                onButtonMaxClicked();
            }
            else
            {
                onButtonRestoreClicked();
            }
        }   
    
        return QWidget::mouseDoubleClickEvent(event);
    }
    
    // 以下通过mousePressEvent、mouseMoveEvent、mouseReleaseEvent三个事件实现了鼠标拖动标题栏移动窗口的效果;
    void MyTitleBar::mousePressEvent(QMouseEvent *event)
    {
        if (m_buttonType == MIN_MAX_BUTTON)
        {
            // 在窗口最大化时禁止拖动窗口;
            if (m_pButtonMax->isVisible())
            {
                m_isPressed = true;
                m_startMovePos = event->globalPos();
            }
        }
        else
        {
            m_isPressed = true;
            m_startMovePos = event->globalPos();
        }
    
        return QWidget::mousePressEvent(event);
    }
    
    void MyTitleBar::mouseMoveEvent(QMouseEvent *event)
    {
        if (m_isPressed)
        {
            QPoint movePoint = event->globalPos() - m_startMovePos;
            QPoint widgetPos = this->parentWidget()->pos();
            m_startMovePos = event->globalPos();
            this->parentWidget()->move(widgetPos.x() + movePoint.x(), widgetPos.y() + movePoint.y());
        }
        return QWidget::mouseMoveEvent(event);
    }
    
    void MyTitleBar::mouseReleaseEvent(QMouseEvent *event)
    {
        m_isPressed = false;
        return QWidget::mouseReleaseEvent(event);
    }
    
    // 加载本地样式文件;
    // 可以将样式直接写在文件中,程序运行时直接加载进来;
    void MyTitleBar::loadStyleSheet(const QString &sheetName)
    {
        QFile file(":/Resources/" + sheetName + ".css");
        file.open(QFile::ReadOnly);
        if (file.isOpen())
        {
            QString styleSheet = this->styleSheet();
            styleSheet += QLatin1String(file.readAll());
            this->setStyleSheet(styleSheet);
        }
    }
    
    // 以下为按钮操作响应的槽;
    void MyTitleBar::onButtonMinClicked()
    {
        emit signalButtonMinClicked();
    }
    
    void MyTitleBar::onButtonRestoreClicked()
    {
        m_pButtonRestore->setVisible(false);
        m_pButtonMax->setVisible(true);
        emit signalButtonRestoreClicked();
    }
    
    void MyTitleBar::onButtonMaxClicked()
    {
        m_pButtonMax->setVisible(false);
        m_pButtonRestore->setVisible(true);
        emit signalButtonMaxClicked();
    }
    
    void MyTitleBar::onButtonCloseClicked()
    {
        emit signalButtonCloseClicked();
    }
    
    // 该方法主要是让标题栏中的标题显示为滚动的效果;
    void MyTitleBar::onRollTitle()
    {
        static int nPos = 0;
        QString titleContent = m_titleContent;
        // 当截取的位置比字符串长时,从头开始;
        if (nPos > titleContent.length())
            nPos = 0;
    
        m_pTitleContent->setText(titleContent.mid(nPos));
        nPos++;
    }
    

    // 窗口基类;

    basewindow.h

    #include <QWidget>
    #include "mytitlebar.h"
    
    class BaseWindow : public QWidget
    {
        Q_OBJECT
    
    public:
        BaseWindow(QWidget *parent = 0);
        ~BaseWindow();
    
    private:
        void initTitleBar();
        void paintEvent(QPaintEvent *event);
        void loadStyleSheet(const QString &sheetName);
    
    private slots:
        void onButtonMinClicked();
        void onButtonRestoreClicked();
        void onButtonMaxClicked();
        void onButtonCloseClicked();
    
    protected:
        MyTitleBar* m_titleBar;
    
    };

    basewindow.cpp

    #include "basewindow.h"
    #include <QDesktopWidget>
    #include <QApplication>
    #include <QPainter>
    #include <QFile>
    
    BaseWindow::BaseWindow(QWidget *parent)
        : QWidget(parent)
    {
        // FramelessWindowHint属性设置窗口去除边框;
        // WindowMinimizeButtonHint 属性设置在窗口最小化时,点击任务栏窗口可以显示出原窗口;
        this->setWindowFlags(Qt::FramelessWindowHint | Qt::WindowMinimizeButtonHint);
        // 设置窗口背景透明;
        setAttribute(Qt::WA_TranslucentBackground);
    
        // 注意!!!如果是主窗口不要设置WA_DeleteOnClose属性;
        // 关闭窗口时释放资源;
        setAttribute(Qt::WA_DeleteOnClose);
        // 初始化标题栏;
        initTitleBar();
    }
    
    BaseWindow::~BaseWindow()
    {
    
    }
    
    void BaseWindow::initTitleBar()
    {
        m_titleBar = new MyTitleBar(this);
        m_titleBar->move(0, 0);
    
        connect(m_titleBar, SIGNAL(signalButtonMinClicked()), this, SLOT(onButtonMinClicked()));
        connect(m_titleBar, SIGNAL(signalButtonRestoreClicked()), this, SLOT(onButtonRestoreClicked()));
        connect(m_titleBar, SIGNAL(signalButtonMaxClicked()), this, SLOT(onButtonMaxClicked()));
        connect(m_titleBar, SIGNAL(signalButtonCloseClicked()), this, SLOT(onButtonCloseClicked()));
    
    }
    
    void BaseWindow::paintEvent(QPaintEvent* event)
    {
        //设置背景色;
        QPainter painter(this);
        QPainterPath pathBack;
        pathBack.setFillRule(Qt::WindingFill);
        pathBack.addRoundedRect(QRect(0, 0, this->width(), this->height()), 3, 3);
        painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
        painter.fillPath(pathBack, QBrush(QColor(238, 223, 204)));
    
        return QWidget::paintEvent(event);
    }
    
    void BaseWindow::loadStyleSheet(const QString &sheetName)
    {
        QFile file(":/Resources/" + sheetName + ".css");
        file.open(QFile::ReadOnly);
        if (file.isOpen())
        {
            QString styleSheet = this->styleSheet();
            styleSheet += QLatin1String(file.readAll());
            this->setStyleSheet(styleSheet);
        }
    }
    
    void BaseWindow::onButtonMinClicked()
    {
        showMinimized();
    }
    
    void BaseWindow::onButtonRestoreClicked()
    {
        QPoint windowPos;
        QSize windowSize;
        m_titleBar->getRestoreInfo(windowPos, windowSize);
        this->setGeometry(QRect(windowPos, windowSize));
    }
    
    void BaseWindow::onButtonMaxClicked()
    {
        m_titleBar->saveRestoreInfo(this->pos(), QSize(this->width(), this->height()));
        QRect desktopRect = QApplication::desktop()->availableGeometry();
        QRect FactRect = QRect(desktopRect.x() - 3, desktopRect.y() - 3, desktopRect.width() + 6, desktopRect.height() + 6);
        setGeometry(FactRect);
    }
    
    void BaseWindow::onButtonCloseClicked()
    {
        close();
    }

    以上代码实现了自定义标题栏,新建的窗口类直接继承BaseWindow类,并对标题栏进行设置即可,下面就测试一下吧!

    测试代码

    NoFocusWidget.cpp

    #include "nofocuswidget.h"
    
    NoFocusWidget::NoFocusWidget(QWidget *parent)
        : BaseWindow(parent)
    {
        ui.setupUi(this);
        // 初始化标题栏;
        initTitleBar();
    }
    
    NoFocusWidget::~NoFocusWidget()
    {
    
    }
    
    void NoFocusWidget::initTitleBar()
    {
        // 设置标题栏跑马灯效果,可以不设置;
        m_titleBar->setTitleRoll();
    
        m_titleBar->setTitleIcon(":/Resources/titleicon.png");
        m_titleBar->setTitleContent(QStringLiteral("前行中的小猪-前行之路还需前行"));
        m_titleBar->setButtonType(MIN_MAX_BUTTON);
        m_titleBar->setTitleWidth(this->width());
    }
    

    main.cpp

    int main(int argc, char *argv[])
    {
        QApplication a(argc, argv);
        NoFocusWidget w;
        w.show();
        return a.exec();
    }

    NoFocusWidget为新建的窗口类,通过继承了BaseWindow类,并在initTitleBar()方法中对标题栏进行设置即可。下图为NoFocusWidget窗口的设计图

    这里写图片描述


    动态效果图

    这里写图片描述


    最大化、还原效果图

    这里写图片描述


    注意

    如果在设置窗口属性时不加上Qt::FramelessWindowHint 就是左图效果。

    this->setWindowFlags(Qt::FramelessWindowHint | Qt::WindowMinimizeButtonHint);

    这里写图片描述

    如果不加上 Qt::WindowMinimizeButtonHint 就是左图效果。加上之后可以看右图效果。

    这里写图片描述这里写图片描述


    以上代码用Qt实现了自定义窗口标题栏,代码很简单,但是很实用,可以应用到每一个窗口中去,保持每个窗口外观的一致性,同时自定义的标题栏也比系统自带的漂亮很多,所以还是非常实用的。

    目前我们在MyTitleBar类以及BaseWindow类中只添加了一些基础功能,小伙伴们可以根据需要添加更多自定义的功能,而其他窗口只需继承BaseWindow类即可。

    欢迎大家一起交流 O(∩_∩)O!

    #代码下载

    Qt 实现 自定义窗口标题栏

    展开全文
  • Qt 之自定义界面(添加自定义标题栏

    万次阅读 多人点赞 2016-01-21 14:58:12
    简述通过上节内容,我们实现了自定义窗体的移动,但是我们缺少一个标题栏来显示窗体的图标、标题,以及控制窗体最小化、最大化、关闭的...效果自定义标题栏实现title_bar.h#ifndef TITLE_BAR #define TITLE_BAR#include

    简述

    通过上节内容,我们实现了自定义窗体的移动,但是我们缺少一个标题栏来显示窗体的图标、标题,以及控制窗体最小化、最大化、关闭的按钮。

    自定义标题栏后,所有的控件我们都可以定制,比如:在标题栏中添加换肤、设置按钮以及其他控件。

    | 版权声明:一去、二三里,未经博主允许不得转载。

    效果

    这里写图片描述

    自定义标题栏

    实现

    title_bar.h

    #ifndef TITLE_BAR
    #define TITLE_BAR
    
    #include <QWidget>
    
    class QLabel;
    class QPushButton;
    
    class TitleBar : public QWidget
    {
        Q_OBJECT
    
    public:
        explicit TitleBar(QWidget *parent = 0);
        ~TitleBar();
    
    protected:
    
        // 双击标题栏进行界面的最大化/还原
        virtual void mouseDoubleClickEvent(QMouseEvent *event);
    
        // 进行鼠界面的拖动
        virtual void mousePressEvent(QMouseEvent *event);
    
        // 设置界面标题与图标
        virtual bool eventFilter(QObject *obj, QEvent *event);
    
    private slots:
    
        // 进行最小化、最大化/还原、关闭操作
        void onClicked();
    
    private:
    
        // 最大化/还原
        void updateMaximize();
    
    private:
        QLabel *m_pIconLabel;
        QLabel *m_pTitleLabel;
        QPushButton *m_pMinimizeButton;
        QPushButton *m_pMaximizeButton;
        QPushButton *m_pCloseButton;
    };
    
    #endif // TITLE_BAR

    title_bar.cpp

    #include <QLabel>
    #include <QPushButton>
    #include <QHBoxLayout>
    #include <QEvent>
    #include <QMouseEvent>
    #include <QApplication>
    #include "title_bar.h"
    
    #ifdef Q_OS_WIN
    #pragma comment(lib, "user32.lib")
    #include <qt_windows.h>
    #endif
    
    TitleBar::TitleBar(QWidget *parent)
        : QWidget(parent)
    {
        setFixedHeight(30);
    
        m_pIconLabel = new QLabel(this);
        m_pTitleLabel = new QLabel(this);
        m_pMinimizeButton = new QPushButton(this);
        m_pMaximizeButton = new QPushButton(this);
        m_pCloseButton = new QPushButton(this);
    
        m_pIconLabel->setFixedSize(20, 20);
        m_pIconLabel->setScaledContents(true);
    
        m_pTitleLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
    
        m_pMinimizeButton->setFixedSize(27, 22);
        m_pMaximizeButton->setFixedSize(27, 22);
        m_pCloseButton->setFixedSize(27, 22);
    
        m_pTitleLabel->setObjectName("whiteLabel");
        m_pMinimizeButton->setObjectName("minimizeButton");
        m_pMaximizeButton->setObjectName("maximizeButton");
        m_pCloseButton->setObjectName("closeButton");
    
        m_pMinimizeButton->setToolTip("Minimize");
        m_pMaximizeButton->setToolTip("Maximize");
        m_pCloseButton->setToolTip("Close");
    
        QHBoxLayout *pLayout = new QHBoxLayout(this);
        pLayout->addWidget(m_pIconLabel);
        pLayout->addSpacing(5);
        pLayout->addWidget(m_pTitleLabel);
        pLayout->addWidget(m_pMinimizeButton);
        pLayout->addWidget(m_pMaximizeButton);
        pLayout->addWidget(m_pCloseButton);
        pLayout->setSpacing(0);
        pLayout->setContentsMargins(5, 0, 5, 0);
    
        setLayout(pLayout);
    
        connect(m_pMinimizeButton, SIGNAL(clicked(bool)), this, SLOT(onClicked()));
        connect(m_pMaximizeButton, SIGNAL(clicked(bool)), this, SLOT(onClicked()));
        connect(m_pCloseButton, SIGNAL(clicked(bool)), this, SLOT(onClicked()));
    }
    
    TitleBar::~TitleBar()
    {
    
    }
    
    void TitleBar::mouseDoubleClickEvent(QMouseEvent *event)
    {
        Q_UNUSED(event);
    
        emit m_pMaximizeButton->clicked();
    }
    
    void TitleBar::mousePressEvent(QMouseEvent *event)
    {
    #ifdef Q_OS_WIN
        if (ReleaseCapture())
        {
            QWidget *pWindow = this->window();
            if (pWindow->isTopLevel())
            {
               SendMessage(HWND(pWindow->winId()), WM_SYSCOMMAND, SC_MOVE + HTCAPTION, 0);
            }
        }
           event->ignore();
    #else
    #endif
    }
    
    bool TitleBar::eventFilter(QObject *obj, QEvent *event)
    {
        switch (event->type())
        {
        case QEvent::WindowTitleChange:
        {
            QWidget *pWidget = qobject_cast<QWidget *>(obj);
            if (pWidget)
            {
                m_pTitleLabel->setText(pWidget->windowTitle());
                return true;
            }
        }
        case QEvent::WindowIconChange:
        {
            QWidget *pWidget = qobject_cast<QWidget *>(obj);
            if (pWidget)
            {
                QIcon icon = pWidget->windowIcon();
                m_pIconLabel->setPixmap(icon.pixmap(m_pIconLabel->size()));
                return true;
            }
        }
        case QEvent::WindowStateChange:
        case QEvent::Resize:
            updateMaximize();
            return true;
        }
        return QWidget::eventFilter(obj, event);
    }
    
    void TitleBar::onClicked()
    {
        QPushButton *pButton = qobject_cast<QPushButton *>(sender());
        QWidget *pWindow = this->window();
        if (pWindow->isTopLevel())
        {
            if (pButton == m_pMinimizeButton)
            {
                pWindow->showMinimized();
            }
            else if (pButton == m_pMaximizeButton)
            {
                pWindow->isMaximized() ? pWindow->showNormal() : pWindow->showMaximized();
            }
            else if (pButton == m_pCloseButton)
            {
                pWindow->close();
            }
        }
    }
    
    void TitleBar::updateMaximize()
    {
        QWidget *pWindow = this->window();
        if (pWindow->isTopLevel())
        {
            bool bMaximize = pWindow->isMaximized();
            if (bMaximize)
            {
                m_pMaximizeButton->setToolTip(tr("Restore"));
                m_pMaximizeButton->setProperty("maximizeProperty", "restore");
            }
            else
            {
                m_pMaximizeButton->setProperty("maximizeProperty", "maximize");
                m_pMaximizeButton->setToolTip(tr("Maximize"));
            }
    
            m_pMaximizeButton->setStyle(QApplication::style());
        }
    }
    

    接口说明

    • mousePressEvent

    之前,我们将界面移动的事件写在主界面里面,这会有一个问题,一般情况下,是界面随着标题栏的移动而移动,而并非界面中的所有位置都可以进行拖动,所以我们将事件写在标题栏中比较合理。

    • mouseDoubleClickEvent

    双击标题栏会进行窗体的最大化/还原,所以我们需要重写此事件进行控制。

    • eventFilter

      1. 事件过滤器,这里被监听的窗体为标题栏所在的窗体,所以当窗体标题、图标等信息发生改变时,标题栏也应该随之改变。

      2. 最好不要通过直接调用接口的形式来操作对应的行为,比如:TitleBar中定义一个public函数来专门修改标题与图标,这样会造成不必要的麻烦,因为Qt本身就是基于事件的,所以此处采用过滤器的方式。

    • updateMaximize

    因为窗体大小发生变化的时候,最大化的图标、提示应该对应的发生变化,所以在eventFilter中事件触发时调用。

    使用方式

    Widget::Widget(QWidget *parent)
        : QWidget(parent)
    {
        setWindowFlags(Qt::FramelessWindowHint | windowFlags());
    
        TitleBar *pTitleBar = new TitleBar(this);
        installEventFilter(pTitleBar);
    
        resize(400, 300);
        setWindowTitle("Custom Window");
        setWindowIcon(QIcon(":/Images/logo"));
    
        QPalette pal(palette());
        pal.setColor(QPalette::Background, QColor(50, 50, 50));
        setAutoFillBackground(true);
        setPalette(pal);
    
        QVBoxLayout *pLayout = new QVBoxLayout();
        pLayout->addWidget(pTitleBar);
        pLayout->addStretch();
        pLayout->setSpacing(0);
        pLayout->setContentsMargins(0, 0, 0, 0);
        setLayout(pLayout);
    }

    注意

    installEventFilter必须在setWindowTitle、setWindowIcon之前调用,因为必须先安装事件过滤器,相应事件触发时,才会进入标题栏的eventFilter事件中。

    展开全文
  • c#自定义标题栏

    千次阅读 2019-10-16 16:24:19
    最近在编写C/S结构应用程序时,感觉窗体的标题栏样式太死板了,标题文字不能更改大小、颜色、字体等,按钮不能隐藏等问题,在网上也查找了许多相关的资料,没有找到合适的解决方案,发现许多人也在寻求这个问题,...
  • 但是这样的做法并不合理,因为标题栏如果有其他的左键单击/击、右键单/双击、甚至滚动事件处理,那么这些动作在非标题栏上也会响应。 这只是提供一个思路,很有意思。 附: 鼠标点击测试枚举值...
  • Winform自定义窗体样式,实现标题栏可灵活自定义 最近在编写C/S结构应用程序时,感觉窗体的标题栏样式太死板了,标题文字不能更改大小、颜色、字体等,按钮不能隐藏等问题,在网上也查找了许多相关的资料,没有找到...
  • (以在窗口标题栏上显示自定义图标为例)  通过本篇,你将知道如何使用图标资源及实质,并有助于你理解在可视化方式编辑使用图标资源过程中的代码实质。  另外,可以触类旁通,明白VC中的Window应用程序对各种...
  • Qt5.9自定义标题栏用法

    千次阅读 2018-07-19 18:39:58
    本博客主要总结创建Qt工程时,不用系统自带的标题栏,而是用自定义的标题栏。其中,自定义标题栏主要原理是,屏蔽原来的标题栏,然后用QVBoxLayout垂直布局管理器,加载一个标题栏QWidget。其中,这个标题栏QWidget...
  • 源代码分析之如何实现自定义的标题栏 本文主要分析Visual Studio Samples\1033\C++\MFC\Visual C++ 2008 Feature Pack\MSMoneyDemo这个Sample 一般窗口的标题栏上面都是只有固定的最小化,恢复,最大化按钮,...
  • Qt自定义标题栏

    千次阅读 2018-11-22 16:31:24
    这里只讲标题栏的创建方法,透明效果与样式我会在下一次介绍。为了让大家能够看清楚效果,上图是我以桌面作为背景。 相信大家可能已经查了很多资料,或者说刚看到我的这篇博客,不过都没关系,因为,看完我这篇,...
  • 对于无标题栏窗体,也就是FormBorderStyle等于System.Windows.Forms.FormBorderStyle.None的窗体,点击任务栏图标的时候,是不能象标准窗体那样最小化或还原的。把下面的代码加到你的Form实现类中,即可实现点击任务...
  • 对于无标题栏窗口,也就是FormBorderStyle等于System.Windows.Forms.FormBorderStyle.None的窗体,点击任务栏图标的时候,是不能和标准窗体一样最小化或还原的。把下面的代码加到你的Form实现类中,即可实现点击任务...
  • 标题栏问号按钮帮助功能的实现

    千次阅读 2008-02-20 10:40:00
    对下面这样的界面我们一定很熟悉,一个对话框,右上角有两个按钮,一个是小问号(我称之“问号按钮”),一个是叉(关闭按钮),点一下...从事软件开发之后,我写过很多程序,很多都有用户界面的,却一般都没有实现这个
  • 众所周知,标题栏和菜单栏都是典型的非客户区,而在Windows平台上,非客户区的自绘对很多程序猿来说,真的是痛苦不堪啊。因此方案一自然而然就被淘汰了。既然如此,那么如何用方案二实现我们要的效果呢? 这里,...
  • 简述 ...自定义标题栏后,所有的控件我们都可以定制,比如:在标题栏中添加换肤、设置按钮以及其他控件。 简述 效果 自定义标题栏 实现 接口说明 使用方式 效果 自定义标题栏 ...
  • Qt自定义外观--自定义标题栏的窗口

    千次阅读 2011-12-13 17:13:58
    可以自定义标题栏, 这里提供一个简单的例子!  例子比较简, 大致思路是正常创建窗口后, 屏蔽标题栏, 通过布局将 一个QLabel和三个按钮 构成一个“标题栏” 放置在顶端(视个人喜好, 位置可以任意放置), ...
  • 自定义标题栏后,所有的控件我们都可以定制,比如:在标题栏中添加换肤、设置按钮以及其他控件。 简述 效果 自定义标题栏 实现 接口说明 使用方式 效果 自定义标题栏 实现 title_bar.h #ifnde
  • 无边框自定义标题栏及最大化最小化窗体大小调整 转自:https://www.cnblogs.com/jyroy/p/9461317.html 陈述 隐藏掉系统的控制栏,实现了自定义的标题控制栏,以及关闭/最大化/最小化的功能,自由调整窗体大小的功能...
  • 如何在标题栏上增加按钮

    千次阅读 2005-01-11 08:50:00
    比如说在主窗口的标题栏上居然有一个按钮。在Internet中随处可见这样的小控件。按钮怎么可以加入到非客户区(Client)呢? ---- 在这里,最关键的一点就是,大家不要被传统知识误导:真的认为它是一个按钮。有名柄...
  • 本文主要讲了Windows XP操作系统任务的十二例实用技巧,这些技巧可以让你更方便、快捷的使用XP的任务。 一、优化分组XP任务 如果你在使用电脑时经常开启多个应用程序,那应该非常珍惜任务上的空间。但是,...
  • Windows 7:77 个 Windows 7 提示

    千次阅读 2010-11-27 21:30:00
    Windows 7:77 个 Windows 7 提示 不论是从 Vista 升级,还是完全跳过 Vista 直接从 Windows XP 升级,您都需要了解如何让 Windows 7 在您的环境中发挥最大功能。下面是与此相关的 77 项提示和技巧。由 Keith ...
  • 1.隐藏标题栏 // 去掉标题栏,去掉工具栏,窗口置顶 setWindowFlags(Qt::FramelessWindowHint | Qt::Tool | Qt::...3.隐藏标题栏实现拖动 隐藏标题栏后窗体是无法拖动的,这个时候就需要重写mous...
  • 一个无边框带默认标题栏的widget

    千次阅读 2015-06-08 10:38:17
    还有一些扩展接口没有添加,有兴趣的同学可以自己添加
  • windows实现远程关机

    千次阅读 2019-03-20 19:43:08
    1、 开启GUEST账号,右键桌面“我的电脑”——选择“管理”项——进入“本地用户和组”,在“用户”项下将GUEST用户启用 2、 打开控制面板——双击进去“管理工具”——双击“本地安全策略” 3、 在“本地安全策略...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,110
精华内容 5,644
关键字:

windows7双击标题栏可以实现