精华内容
下载资源
问答
  • 键盘移动对话框

    2010-03-02 18:48:00
    对话框 标题栏 键盘操作 移动 Alt+Space->移动 键盘上下左右移动 参考:http://z.baidu.com/question/14001925.html

    对话框 标题栏 键盘操作 移动

     

    Alt+Space->移动

     

    键盘上下左右移动

     

     

    参考:

    http://z.baidu.com/question/14001925.html

    展开全文
  • // 本例子我们使用自定义的对话框类 #include "DemoDialog.h" // 下边演示如何检测内存泄漏. 在每个要检测的文件中加上下边2句. // 要注意的是这两句必须放在包含其他的头文件之后. 否则会产生编译/连接错误. //...
    //board.h
    
    #ifndef __BOARD_H__
    #define __BOARD_H__
     
    
    #include "SexyAppFramework/Widget.h"
    #include "SexyAppFramework/ButtonListener.h"
     
    #include "SexyAppFramework/EditListener.h"
    #include "SexyAppFramework/CheckboxListener.h"
    #include "SexyAppFramework/ListListener.h"
     
    
    
    class Graphics;
    class GameApp;
    class ButtonWidget;
    class WidgetManager;
    class Image;
    
    //定义视差层结构体
    struct ParallaxLayer
    {
     float  mX;
     float  mY;
     Image*  mImage;
    };
    
    
    class Board : public Widget, public ButtonListener
    {
      GameApp*   mApp;
      ButtonWidget*  mButton;
    
      // 使用3层图片 (即一些背景靠前一些背景靠后. 移动的时候前边的背景移动较快)
      struct ParallaxLayer mLayer[3];  
    
     public: 
      enum { OPTIONS_BUTTON_ID };
    
      Board(GameApp* theApp);
      virtual ~Board();  
    
      //
      // 当有键盘键按下时调用. 
      virtual void KeyDown(KeyCode theKey);
      //
      // 它和KeyDown()不同. 它只能处理 ascii 输入 
      //virtual void KeyChar(char theChar);
     
      virtual void Draw(Graphics* g); 
      virtual void Update();  
      virtual void ButtonDepress(int theId);  
      virtual void AddedToManager(WidgetManager* theWidgetManager); 
      virtual void RemovedFromManager(WidgetManager* theWidgetManager);
       
    };
    
     
    
    #endif // __BOARD_H__
    
    //gameapp.h
    
    #ifndef __GAMEAPP_H__
    #define __GAMEAPP_H__
    
    #include "SexyAppFramework/SexyAppBase.h"
    
    
     class Board; 
     class TitleScreen; 
     class Dialog;
    
    class GameApp : public SexyAppBase
    {
      Board*   mBoard;
      TitleScreen* mTitleScreen;
    
     public:
    
      GameApp();
      virtual ~GameApp();
      virtual void Init(); 
      virtual void LoadingThreadProc();
      virtual void LoadingThreadCompleted(); 
      void TitleScreenIsFinished();
    
    
      //  
      //我们经常需要调用基类的 SexyAppBase::DoDialog() 来创建对话框. 
      //而后者会调用虚函数 NewDialog(). 我们在此重写 NewDialog() 使其调用我们重写版的. 
      //这样我们可以在其中指定对话框的通用的皮肤等.
      //该参数的意义参照 Dialog()构造函数的后几个参数.
      virtual Dialog* NewDialog(int theDialogId, bool isModal, const std::string& theDialogHeader, 
            const std::string& theDialogLines, const std::string& theDialogFooter, int theButtonMode);
     
      //  
      // 基类的函数. 用来设置是否3D 以及 是否全屏.
      // 本例中我们在对话框中用一个单选框来设置/记录是否全屏. 
      // 但有这样一种可能: 该对话框显示的时候用户按 ALT+ENTER 来使程序全屏模式运行. 
      // 而这时对话框中的单选按钮的状态还没有被改变. 这就是要改写该函数的原因.
      virtual void SwitchScreenMode(bool wantWindowed, bool is3d);
     
      virtual void ButtonPress(int theId);
    
      //
      // 自定义的函数. 用来使 Board 部件获得焦点.
      void SetFocusToBoard();
    };
     
    
    #endif // __GAMEAPP_H__
    
    //demoDialog.h
    
    //
    //    DemoDialog.h
    // 这里示范如何自定义一个对话框. 
    // (如果是简单的 Yes/No/OK 消息框. 
    //  则只要重写app类的 NewDialog()并在需要的时候调用app的DoDialog()就可以了.
    //  不必这么麻烦. )
    //
    
    #ifndef __DEMO_DIALOG_H__
    #define __DEMO_DIALOG_H__
    
    #include "SexyAppFramework/Dialog.h"
    #include "SexyAppFramework/SliderListener.h"
    #include "SexyAppFramework/CheckboxListener.h"
     
    class Graphics; 
    // 滑动条部件. (这里用来控制音量).
    class Slider;
    
    // 使用DialogButton类而不是 ButtonWidget. 因为DialogButton可以自动使皮肤图片覆盖到按钮大小.
    class DialogButton;
    class Checkbox;
    
    // 对话框从 Dialog 类派生.
    class DemoDialog : public Dialog, public SliderListener, public CheckboxListener
    {
      //对话框中包含的部件们
      Slider*   mMusicVolumeSlider;
      Slider*   mSfxVolumeSlider;
      DialogButton* mRandomBtn;    // 生成随机数按钮
      DialogButton* mClipBtn;    
    
     public:
    
      // 部件ID使用的常数
      enum{MUSIC_SLIDER_ID, SFX_SLIDER_ID, RANDOM_BTN_ID, CLIP_BTN_ID, FS_CHECKBOX_ID, HARDWARE_CHECKBOX_ID, MESSAGE_BOX_ID, DIALOG_ID};
    
      Checkbox*  m3DCheckbox;   // 3D效果
      Checkbox*  mFSCheckbox;   // 全屏效果
    
     
     public:
      // 构造 
      // 参数为 对话框的标题字符串. 对话框中的文字(文字可以换行).
      DemoDialog(std::string theHeader, std::string theBody);
      virtual ~DemoDialog();
     
      // 重写基类的函数
      virtual void Draw(Graphics* g); 
      virtual void Update();
      
      virtual void ButtonDepress(int theId); 
      virtual void AddedToManager(WidgetManager* theWidgetManager); 
      virtual void RemovedFromManager(WidgetManager* theWidgetManager);
    
      // 改变对话框大小时. 会调用该函数. 我们需要在此布局自定义对话框包含的部件们.
      virtual void Resize(int theX, int theY, int theWidth, int theHeight);
    
      //
      // 滑动条部件有操作时. 会调用它来处理.
      // 参数为 滑动条的ID, 当前值(从0到最大值).
      virtual void SliderVal(int theId, double theVal);
    
      //
      // 单选框事件处理函数
      void CheckboxChecked(int theId, bool checked);
    };
    
     
    
    #endif
    
    // board.cpp
    
    #include "Board.h"
    #include "GameApp.h"
    
    // Contains all the resources from the resources.xml file in our
    // properties directory. See that file for more information.
    #include "Res.h"
     
    #include "SexyAppFramework/Graphics.h"
    #include "SexyAppFramework/Color.h"
    #include "SexyAppFramework/Rect.h"
    #include "SexyAppFramework/ButtonWidget.h"
    #include "SexyAppFramework/WidgetManager.h"
    #include "SexyAppFramework/ImageFont.h"
    #include "SexyAppFramework/Image.h"
    
    // 本例子我们使用自定义的对话框类
    #include "DemoDialog.h" 
     
    // 下边演示如何检测内存泄漏.  在每个要检测的文件中加上下边2句. 
    // 要注意的是这两句必须放在包含其他的头文件之后. 否则会产生编译/连接错误.
    // 如果使用内存泄漏检测. 在程序结束时检测的结果会写入"mem_leaks.txt"文件.
    #define SEXY_MEMTRACE
    #include "SexyAppFramework/memmgr.h"
    
    using namespace Sexy;
     
    //
    Board::Board(GameApp* theApp)
    {
     mApp = theApp;  
     mButton = NULL;
    
     // 初始化3个视差层. 
     for (int i = 0; i < 3; i++)
     {
      mLayer[i].mX = 0;
    
      // 设置 mLayer[i] 的图片. 例如第一层的图片ID是 IMAGE_BG1, 第二层是IMAGE_BG2...
    
      std::string imageStringID = StrFormat("IMAGE_BG%d", i);
      // 把上边构造的字符串ID映射到对应的整数ID. 函数 GetIdByStringId() 我们定义在res.cpp中
      int id = GetIdByStringId(imageStringID.c_str()); 
      // 通过该ID取得对应的图片对象的指针. 函数GetImageById() 我们也定义在res.cpp中.
      mLayer[i].mImage = GetImageById(id);
     
      mLayer[i].mY = (float)(mApp->mHeight - mLayer[i].mImage->GetHeight());
     }
    
     // 故意泄漏一块内存. 做为测试用.
     int* aLeakedInteger = new int;
     
    }
     
    Board::~Board()
    {
     delete mButton;
    }
     
    void Board::Update()
    {   
     Widget::Update(); 
     MarkDirty(); 
    }
     
    void Board::KeyDown(KeyCode theKey)
    {
     // 当按下左右箭头时. 水平移动这3个层. 但每个层移动的速度不同.
     if (theKey == KEYCODE_RIGHT)
     {
      for (int i = 0; i < 3; i++)
      { 
       mLayer[i].mX -= 1.0f * (i + 1);
       if (mLayer[i].mX <= -mLayer[i].mImage->GetWidth())
        mLayer[i].mX = 0;
      }
     }
     else if (theKey == KEYCODE_LEFT)
     {
      for (int i = 0; i < 3; i++)
      { 
       mLayer[i].mX += 1.0f * (i + 1);
       if (mLayer[i].mX >= mLayer[i].mImage->GetWidth())
        mLayer[i].mX = 0;
      }
     }
    }
     
    void Board::Draw(Graphics* g)
    {  
     g->SetColor(Color(0, 0, 0));
     g->FillRect(0, 0, mWidth, mHeight);
    
    
     for (int i = 0; i < 3; i++)
     {
      int imgWidth = mLayer[i].mImage->GetWidth();
    
      
      // 设置新的绘制原点. 则绘制函数使用的(x,y)都是对这个点的偏移值.
      g->TranslateF(mLayer[i].mX, mLayer[i].mY);
     
      // 根据是否有3D加速. 使用不同的绘制函数.
      if (mApp->Is3DAccelerated())
      {  
       g->DrawImageF(mLayer[i].mImage, (float)-imgWidth, 0.0f);
       g->DrawImageF(mLayer[i].mImage, 0.0f, 0.0f);
       g->DrawImageF(mLayer[i].mImage, (float)imgWidth, 0.0f);
      }
      else
      { 
       g->DrawImage(mLayer[i].mImage, -imgWidth, 0);
       g->DrawImage(mLayer[i].mImage, 0, 0);
       g->DrawImage(mLayer[i].mImage, imgWidth, 0);
      }
    
      // 将绘制原点移动回来..
      g->TranslateF(-mLayer[i].mX, -mLayer[i].mY);
     } 
    } 
     
    void Board::AddedToManager(WidgetManager* theWidgetManager)
    { 
     Widget::AddedToManager(theWidgetManager);
     
     mButton = new ButtonWidget(Board::OPTIONS_BUTTON_ID, this); 
     mButton->SetFont(FONT_DEFAULT);
     mButton->mLabel = _S("Click Me!");
     
     // 这次我们为按钮带点皮肤.
     mButton->mOverImage = IMAGE_BUTTON_OVER;      // 鼠标经过图片
     mButton->mDownImage = IMAGE_BUTTON_DOWN;      // 按钮按下图片
     mButton->mButtonImage = IMAGE_BUTTON_NORMAL;  // 正常按钮图片
     mButton->mDoFinger = true;  //允许鼠标移上时鼠标变为手形.
     mButton->Resize(56, 5, IMAGE_BUTTON_NORMAL->GetWidth(), IMAGE_BUTTON_NORMAL->GetHeight());
    
     theWidgetManager->AddWidget(mButton);
    }
     
    //
    void Board::RemovedFromManager(WidgetManager* theWidgetManager)
    { 
     Widget::RemovedFromManager(theWidgetManager); 
     theWidgetManager->RemoveWidget(mButton);
    }
     
    //
    void Board::ButtonDepress(int theId)
    {  
     if (theId == Board::OPTIONS_BUTTON_ID)
     { 
      // 创建自定义的对话框.
      DemoDialog* dlg = new DemoDialog("Header", "Hello! I am a dialog box.");
      dlg->Resize(50, 50, 300, 400);
      // 对于对话框. 我们不把它加入 WidgetManager. 而是调用如下函数:
      mApp->AddDialog(DemoDialog::DIALOG_ID, dlg);
     }
    }
    
    //gameapp.cpp
    
    
    #include "GameApp.h"
    #include "TitleScreen.h"
    #include "Board.h"
    #include "DemoDialog.h"
    #include "SexyAppFramework/WidgetManager.h"
    
    #include "SexyAppFramework/Checkbox.h"
    
    // We will be accessing the resource manager in this demo, so include it's header
    #include "SexyAppFramework/ResourceManager.h"
    
    // Required for playing music
    #include "SexyAppFramework/BassMusicInterface.h"
    
    // Contains all the resources from the resources.xml file in our
    // properties directory. See that file for more information.
    #include "Res.h"
    
    #include "SexyAppFramework/Dialog.h" 
    using namespace Sexy;
    
    
    //
    //
    GameApp::GameApp()
    { 
     mProdName = "Demo 5"; 
     mProductVersion = "1.0"; 
     mTitle = StringToSexyStringFast("SexyAppFramework: " + mProdName + " - " + mProductVersion); 
     mRegKey = "PopCap\SexyAppFramework\Demo5";
    
     mWidth = 640;
     mHeight = 480;
     
     mAutoEnable3D = true;
    
     mBoard = NULL;
     mTitleScreen = NULL; 
    }
     
    //
    GameApp::~GameApp()
    { 
     if (mBoard != NULL)
      mWidgetManager->RemoveWidget(mBoard); 
     delete mBoard;
    
     if (mTitleScreen != NULL)
      mWidgetManager->RemoveWidget(mTitleScreen);
     delete mTitleScreen;
     
     mResourceManager->DeleteResources("Init");
     mResourceManager->DeleteResources("TitleScreen");
     mResourceManager->DeleteResources("Game"); 
    }
     
    //
    void GameApp::Init()
    { 
     SexyAppBase::Init();
    
     //加载资源.
    
    
     LoadResourceManifest();
     
     if (!mResourceManager->LoadResources("Init"))
     {
      mLoadingFailed = true;
      // 显示资源加载失败信息
      ShowResourceError(true);
      return;
     }
     
     if (!ExtractInitResources(mResourceManager))
     {
      mLoadingFailed = true;
      ShowResourceError(true);
      return;
     }
     
     if (!mResourceManager->LoadResources("TitleScreen"))
     {
      mLoadingFailed = true;
      ShowResourceError(true);
      return;
     }
    
     if (!ExtractTitleScreenResources(mResourceManager))
     {
      mLoadingFailed = true;
      ShowResourceError(true);
      return;
     }
    
     // 开始前导屏幕
     mTitleScreen = new TitleScreen(this);
     mTitleScreen->Resize(0, 0, mWidth, mHeight); 
     mTitleScreen->Init(); 
     mWidgetManager->AddWidget(mTitleScreen);
    
     mMusicInterface->LoadMusic(0, "music/music.mo3");
     mMusicInterface->LoadMusic(1, "music/music.mo3");
     mMusicInterface->FadeIn(0, 0, 0.002, false);
    
    
     mNumLoadingThreadTasks = mResourceManager->GetNumResources("Game");
    }
    
    // 
    void GameApp::LoadingThreadProc()
    { 
     // 加载资源
     mResourceManager->StartLoadResources("Game");
    
     while (mResourceManager->LoadNextResource())
     { 
      mCompletedLoadingThreadTasks++; 
      if (mShutdown)
       return;
    
      mTitleScreen->MarkDirty();
     }
     
     if (mResourceManager->HadError() || !ExtractGameResources(mResourceManager))
     {  
      ShowResourceError(false);
      mLoadingFailed = true;
      return;
     }
     
    }
    
    // 
    void GameApp::LoadingThreadCompleted()
    { 
     SexyAppBase::LoadingThreadCompleted();
     
     if (mLoadingFailed)
      return;
     
     mTitleScreen->LoadingComplete(); 
     mTitleScreen->MarkDirty();
    }
     
    //
    void GameApp::TitleScreenIsFinished()
    {
     // 结束前导屏幕. 开始 board部件.
     mTitleScreen = NULL;
     mBoard = new Board(this);
    
     // 释放前导屏幕使用的资源
     mResourceManager->DeleteResources("TitleScreen");
    
     mBoard->Resize(0, 0, mWidth, mHeight);
     mWidgetManager->AddWidget(mBoard);
    
     // 使输入焦点放在 mBoard 上. 
     mWidgetManager->SetFocus(mBoard);
    
     // 淡出声音0.淡入声音1.
     mMusicInterface->FadeOut(0, true, 0.004); 
     mMusicInterface->FadeIn(1, 9, 0.002, false); 
    }
     
    //
    // 改写基类的NewDialog()函数
    // 这个函数会被基类的 DoDialog() 调用. 在这里我们可以设置对话框通用一些特征. 例如皮肤. 字体. 大小等.
    Dialog* GameApp::NewDialog(int theDialogId, bool isModal, const std::string& theDialogHeader, 
             const std::string& theDialogLines, const std::string& theDialogFooter, int theButtonMode)
    {
     // 下边的 Dialog() 构造函数指定了对话框皮肤和按钮皮肤. 这样我们以后使用 YES/NO 对话框时就自动拥有这些皮肤了.
     Dialog* d = new Dialog(IMAGE_DIALOG_BOX, IMAGE_DIALOG_BUTTON, theDialogId, isModal,
           StringToSexyStringFast(theDialogHeader), StringToSexyStringFast(theDialogLines), StringToSexyStringFast(theDialogFooter), theButtonMode);
    
     d->SetButtonFont(FONT_DEFAULT);
     d->SetLinesFont(FONT_DEFAULT);
     d->SetHeaderFont(FONT_DEFAULT);
    
     d->SetColor(Dialog::COLOR_HEADER, Color::Black);
     d->SetColor(Dialog::COLOR_LINES, Color::Black);
    
     d->mSpaceAfterHeader = 30;
     d->Resize(100, 100, 300, 250);
    
     return d;
    }
     
    //
    // 在设置3D模式  全屏模式 时. 我们想干点其他事...
    void GameApp::SwitchScreenMode(bool wantWindowed, bool is3d)
    { 
     SexyAppBase::SwitchScreenMode(wantWindowed, is3d);
    
     // 根据对话框ID得到对话框的指针. 这需要调用 SexyAppBase::GetDialog().
     DemoDialog* d = (DemoDialog*) GetDialog(DemoDialog::DIALOG_ID);
    
     // 即使用户通过Alt+Enter的办法切换全屏/窗口模式. 也应该使单选框 mFSCheckbox 的状态和它保持一致.
     if ((d != NULL) && (d->mFSCheckbox != NULL))
      d->mFSCheckbox->SetChecked(!wantWindowed);
    
    }
     
    //
    void GameApp::ButtonPress(int theId)
    {
     // 点对话框底部的按钮时. 关掉该对话框.
     if (theId == DemoDialog::MESSAGE_BOX_ID + 2000)
      KillDialog(theId - 2000);  //关闭对话框.
    }
     
    //
    void GameApp::SetFocusToBoard()
    {
     if (mBoard != NULL)
      mWidgetManager->SetFocus(mBoard);
    }
    
    //demoDialog.cpp
    
    #include "DemoDialog.h"
    #include "Res.h"
    #include "GameApp.h"
    #include "SexyAppFramework/SexyAppBase.h"
    #include "SexyAppFramework/WidgetManager.h"
    #include "SexyAppFramework/Font.h"
    #include "SexyAppFramework/DialogButton.h"
    #include "SexyAppFramework/Checkbox.h"
     
    #include "SexyAppFramework/Slider.h"
    
    using namespace Sexy;
    
    // 
    // 对话框的基类 Dialog 的构造函数参数:
    //  对话框的外观图片 (本例中的图片在 images/dialog.gif)
    //  对话框中按钮的图片(本例中的图片在 images/dialog_btn.gif)
    //  对话框ID
    //  是否模式对话框
    //  对话框顶部文字
    //  对话框中间文字(可以用 \n 分行)
    //  如果允许最下部按钮( 即下一个参数是 Dialog::BUTTONS_FOOTER ). 这个参数是按钮上的文字. 
    //  最后一个参数是对话框带的默认按钮的风格: 可以是 
    //   // BUTTONS_YES_NO    //YES按钮的ID为: ID_YES    //NO按钮的ID为: ID_NO
    //   // BUTTONS_OK_CANCEL //OK按钮的ID为: ID_OK    //CANCEL按钮的ID为: ID_CANCEL
    //   // BUTTONS_NONE(没有默认按钮)
    //   // BUTTONS_FOOTER(对话框底部有一个按钮).    //该按钮的ID为 ID_FOOTER 
    //
    DemoDialog::DemoDialog(std::string theHeader, std::string theBody) :
    Dialog(IMAGE_DIALOG_BOX, IMAGE_DIALOG_BUTTON, DemoDialog::DIALOG_ID, true, StringToSexyStringFast(theHeader), StringToSexyStringFast(theBody), _S("CLOSE"), Dialog::BUTTONS_FOOTER)
    {
     // 为对话框设置一个区域. 其中所有的文本/按钮等等都会被调整到该区域内.
     mContentInsets = Insets(23, 20, 23, 20);  // Insets()的参数表示区域到四边的距离
    
     // 设置对话框中间的文字(参数theBody) 显示时距离标题栏的距离 
     mSpaceAfterHeader = 30;
    
     // 设置对话框的 标题字体.  中间文字的字体.  按钮的字体.
     SetHeaderFont(FONT_DEFAULT);
     SetLinesFont(FONT_DEFAULT);
     SetButtonFont(FONT_DEFAULT);
    
     // 设置对话框使用的一些颜色.
     SetColor(COLOR_HEADER, Color::Black);
     SetColor(COLOR_LINES, Color::Black);
     
     // 创建滑动条部件. Slider的构造函数参数分别是:
     //  滑动路径图片.  滑块图片.  本部件ID,   监听者
     mMusicVolumeSlider = new Slider(IMAGE_SLIDER_TRACK, IMAGE_SLIDER_THUMB, DemoDialog::MUSIC_SLIDER_ID, this);
     
     // 设置滑块的当前位置值(范围在0.0 - 1.0 之间). 这里我们设置为当前的音量. 
     // 获取当前音量用 SexyAppBase::GetMusicVolume() 函数. 
     mMusicVolumeSlider->SetValue(gSexyAppBase->GetMusicVolume()); //对话框部件没有保存App的指针. 但可以使用声明在SexyAppBase.h文件的 gSexyAppBase
    
     // 另一个滑动条部件
     mSfxVolumeSlider = new Slider(IMAGE_SLIDER_TRACK, IMAGE_SLIDER_THUMB, DemoDialog::SFX_SLIDER_ID, this); 
     mSfxVolumeSlider->SetValue(gSexyAppBase->GetSfxVolume());
    
     // 创建按钮.  使用 DialogButton 类 而不是它的父类 ButtonWidget.
     // 构造函数参数为:   按钮图片.  按钮ID.  监听器
     mRandomBtn = new DialogButton(IMAGE_DIALOG_BUTTON, DemoDialog::RANDOM_BTN_ID, this);
     mRandomBtn->mLabel = _S("Random #");
     mRandomBtn->SetFont(FONT_DEFAULT);
     
     mClipBtn = new DialogButton(IMAGE_DIALOG_BUTTON, DemoDialog::CLIP_BTN_ID, this);
     mClipBtn->mLabel = _S("Clipping");
     mClipBtn->SetFont(FONT_DEFAULT);
    
     m3DCheckbox = new Checkbox(IMAGE_CHECKBOX, IMAGE_CHECKBOX, DemoDialog::HARDWARE_CHECKBOX_ID, this);
     mFSCheckbox = new Checkbox(IMAGE_CHECKBOX, IMAGE_CHECKBOX, DemoDialog::FS_CHECKBOX_ID, this);
    }
    
    //
    //
    DemoDialog::~DemoDialog()
    {
     delete mMusicVolumeSlider;
     delete mSfxVolumeSlider;
     delete mRandomBtn;
     delete mClipBtn;
     delete m3DCheckbox;
     delete mFSCheckbox;
    }
    
    // 
    void DemoDialog::Draw(Graphics* g)
    {
     Dialog::Draw(g);
     
     // 绘制几个文字.
     g->SetFont(FONT_DEFAULT);
     g->SetColor(Color::Black); 
     g->DrawString(_S("Music volume:"), mMusicVolumeSlider->mX - mX, 
       mMusicVolumeSlider->mY - mY - mMusicVolumeSlider->mHeight);
     g->DrawString(_S("Sound volume:"), mSfxVolumeSlider->mX - mX, 
       mSfxVolumeSlider->mY - mY - mSfxVolumeSlider->mHeight);
     g->DrawString(_S("3D Mode:"), m3DCheckbox->mX - mX, m3DCheckbox->mY - mY - m3DCheckbox->mHeight + 20);
     g->DrawString(_S("Full Screen:"), mFSCheckbox->mX - mX, mFSCheckbox->mY - mY - mFSCheckbox->mHeight + 20);
    
     // 在对话框的矩形区域之外绘制一点东西.
     // 但只有当基类的 mClip 成员被设置时这些东西才能真正绘制到屏幕上. 
     g->SetColor(Color(255, 0, 0, 128));  
     g->FillRect(mWidth, mHeight, 100, 100); 
     g->FillRect(-100, -100, 100, 100);
     g->SetColor(Color::Black);
     g->DrawString(_S("Top left"), -90, -20);
     g->DrawString(_S("Bottom right"), mWidth + 10, mHeight + 20);
    }
    
    // 
    void DemoDialog::Update()
    {
     Dialog::Update();
    }
    
     
    //
    void DemoDialog::AddedToManager(WidgetManager* theWidgetManager)
    {
     Dialog::AddedToManager(theWidgetManager);
     theWidgetManager->AddWidget(mMusicVolumeSlider);
     theWidgetManager->AddWidget(mSfxVolumeSlider);
     theWidgetManager->AddWidget(mRandomBtn);
     theWidgetManager->AddWidget(mClipBtn);
    
     int checkWidth = IMAGE_CHECKBOX->GetWidth() / 2;
     m3DCheckbox->mUncheckedRect = Rect(0, 0, checkWidth, IMAGE_CHECKBOX->GetHeight());
     m3DCheckbox->mCheckedRect = Rect(checkWidth, 0, checkWidth, IMAGE_CHECKBOX->GetHeight());
    
     mFSCheckbox->mUncheckedRect = Rect(0, 0, checkWidth, IMAGE_CHECKBOX->GetHeight());
     mFSCheckbox->mCheckedRect = Rect(checkWidth, 0, checkWidth, IMAGE_CHECKBOX->GetHeight());
      
     m3DCheckbox->mChecked = gSexyAppBase->Is3DAccelerated();
      
     mFSCheckbox->mChecked = !gSexyAppBase->mIsWindowed;
    
     theWidgetManager->AddWidget(m3DCheckbox);
     theWidgetManager->AddWidget(mFSCheckbox);
    }
    
    //
    //
    void DemoDialog::RemovedFromManager(WidgetManager* theWidgetManager)
    {
     Dialog::RemovedFromManager(theWidgetManager);
     theWidgetManager->RemoveWidget(mMusicVolumeSlider);
     theWidgetManager->RemoveWidget(mSfxVolumeSlider);
     theWidgetManager->RemoveWidget(mRandomBtn);
     theWidgetManager->RemoveWidget(mClipBtn);
     theWidgetManager->RemoveWidget(m3DCheckbox);
     theWidgetManager->RemoveWidget(mFSCheckbox);
    }
    
    //
    //设置对话框大小时改变它的部件的布局.
    void DemoDialog::Resize(int theX, int theY, int theWidth, int theHeight)
    {
     Dialog::Resize(theX, theY, theWidth, theHeight);  //先调用基类的Resize()
     
     // 调整每个部件的位置/大小. 使其适应对话框的 mContentInsets 区域.
     mMusicVolumeSlider->Resize(theX + mContentInsets.mLeft, 
            theY + 140,
            mWidth - mContentInsets.mLeft - mContentInsets.mRight,
            IMAGE_SLIDER_THUMB->GetHeight());
     
     // 用另一种方法布局部件.
     // 这里设置第二个滑动条部件. 它和 mMusicVolumeSlider 的x坐标.宽度.高度一样. 只是Y坐标低一些. 
     // 所以这里根据 mMusicVolumeSlider 的位置来布局它.
     mSfxVolumeSlider->Layout(LAY_SameLeft | LAY_Below | LAY_SameWidth | LAY_SameHeight, 
            mMusicVolumeSlider, 0, 40, 0, 0);
    
     // 同样. 根据 mSfxVolumeSlider 的位置布局 mRandomBtn.
     mRandomBtn->Layout(LAY_SameLeft | LAY_SameTop, mSfxVolumeSlider, 0, 40, 0, 0);
     mRandomBtn->Resize(mRandomBtn->mX, mRandomBtn->mY, 
          mSfxVolumeSlider->mWidth / 2, IMAGE_DIALOG_BUTTON->mHeight);
    
     // 再根据 mRandomBtn 的位置和 对话框mContentInsets的区域边界来调整 mClipBtn 部件的位置.
     mClipBtn->Layout(LAY_Right | LAY_SameTop | LAY_SameWidth | LAY_SameHeight,
          mRandomBtn, 0, 0, 0, 0);
    
     //布局两个单选框
     m3DCheckbox->Layout(LAY_SameLeft | LAY_Below, mRandomBtn, 0, 40, 0, 0);
     m3DCheckbox->Resize(m3DCheckbox->mX, m3DCheckbox->mY,
          IMAGE_CHECKBOX->mWidth / 2, IMAGE_CHECKBOX->mHeight); 
     mFSCheckbox->Layout(LAY_SameTop | LAY_SameWidth | LAY_SameHeight, m3DCheckbox);
     mFSCheckbox->Layout(LAY_SameLeft, mClipBtn);
    
    }
    
    //
    //处理滑动条事件
    void DemoDialog::SliderVal(int theId, double theVal)
    {
     if (theId == DemoDialog::MUSIC_SLIDER_ID)
     {
      gSexyAppBase->SetMusicVolume(theVal);
     }
     else if (theId == DemoDialog::SFX_SLIDER_ID)
     {
      gSexyAppBase->SetSfxVolume(theVal);
    
      // 当用户鼠标释放滑块时播放提示音.
      if (!mSfxVolumeSlider->mDragging)
       gSexyAppBase->PlaySample(SOUND_TIMER);
     }
    }
     
    //
    void DemoDialog::ButtonDepress(int theId)
    {
     Dialog::ButtonDepress(theId);
    
     if (theId == mRandomBtn->mId)   //按钮的ID记录在 ButtonWidget::mID .
     {
      // 点击 Random 按钮时. 生成一个随机整数. 
      int r = Rand();
    
      // 并设置 该整数串做为对话框的 中间文字.
      // 可以看出. 修改对话框的中的文字很容易. 只要修改 mDialogLines 成员即可.
      mDialogLines = StrFormat(_S("Random number: %d"), r); 
     }
     else if (theId == mClipBtn->mId)
     { 
      // 点击这个按钮时我们设置基类的 mClip 成员(该成员声明在WidgetContainer类中). 
      // 当 mClip 关闭时我们可以在该部件的矩形区域之外绘制. 
      mClip = !mClip;
      if (mClip)
       mClipBtn->mLabel = _S("Clipping");
      else
       mClipBtn->mLabel = _S("No clipping");
     }
    
     else if (theId == ID_YES)
     { 
      // 点击这个按钮将要关闭对话框. 在这里我们使用户的设置生效.
      // 调用 app 的 SwitchScreenMode() 可以设置全屏/窗口模式. 以及是否3D.
      gSexyAppBase->SwitchScreenMode(!mFSCheckbox->mChecked, m3DCheckbox->mChecked);
      
      // 关掉对话框.
      gSexyAppBase->KillDialog(this);
     
      ((GameApp*)gSexyAppBase)->SetFocusToBoard();  //设置焦点
     }
     
    }
    
    //
    // 处理单选框事件
    void DemoDialog::CheckboxChecked(int theId, bool checked)
    { 
     if (theId == m3DCheckbox->mId)
     {
      if (checked)
      { 
       if (!gSexyAppBase->Is3DAccelerationSupported())
       {
        //如果3D不被支持. 则不设置该单选框. 并弹出一个对话框通知用户.
        m3DCheckbox->SetChecked(false);
    
        //调用 SexyAppBase::DoDialog() 来创建对话框. 
        //这个函数将调用 NewDialog() 来创建对话框. 而NewDialog()调用的是我们重写版的. 我们在其中指定了对话框的通用的皮肤等.
        //参数的意义参照 Dialog()构造函数的后几个参数.
        gSexyAppBase->DoDialog(DemoDialog::MESSAGE_BOX_ID, true, _S("Not Supported"), 
           _S("Hardware acceleration can not be enabled on this computer. \nYour\
           video card does not meet the minimum requirements for this game."),
           _S("OK"), Dialog::BUTTONS_FOOTER);
       }
       else if(!gSexyAppBase->Is3DAccelerationRecommended())
       { 
        gSexyAppBase->DoDialog(DemoDialog::MESSAGE_BOX_ID, true, _S("Warning"), 
         _S("Your video card may not fully support this feature.\n\
         If you experience slower performance, please disable Hardware Acceleration."),
         _S("OK"), Dialog::BUTTONS_FOOTER);
       }
       
      }
     }
     else if (theId == mFSCheckbox->mId)
     { 
      if (gSexyAppBase->mForceFullscreen && !checked)
      {
       gSexyAppBase->DoDialog(DemoDialog::MESSAGE_BOX_ID, true, _S("No Windowed Mode"),
       _S("Windowed mode is only available if your desktop is running in\n\
       either 16 bit or 32 bit color mode, which it is not."), _S("OK"), Dialog::BUTTONS_FOOTER);
     
       mFSCheckbox->SetChecked(true);
      }
     }
    }
    
    //main.cpp
    
    //
    // 本例子学习:
    //
    // * Drawing differently if 3D or 2D
    // * Using Translate instead of using XYs
    // * 键盘输入. 设置输入焦点.
    // * 学习新的部件: 对话框. 滑动条. 
    // * Advanced widget topics: mClip, using Layout_ flags, using images
    // * 设置3D模式. 全屏模式. 设置音量.
    // * Parallax scrolling
    // * 随机数
    // * 检测内存泄漏
    // * Profiling
    //
    
    #include "GameApp.h"
     
    using namespace Sexy;
    
    int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
    {  
     gHInstance = hInstance; 
     GameApp* anApp = new GameApp();
     anApp->Init(); 
     anApp->Start();
    
     delete anApp;
    
     return 0;
    }

    展开全文
  • 对话框这种常用的组件,过一...就是本文介绍的,随着软键盘的弹起自动移动位置的对话框。 先封装实现个baseDialog基础类,把通用的操作封装一下。 package com.newcapec.visitorsystem.dialog; import androi

    像对话框这种常用的组件,用过一次最好做个封装。再次用到时就很简单啦。直接拿过来复用即可。

    以下是工作中用到的管理员登录框,由于是双屏异显,在后屏弹出的对话框,没法调用系统软键盘,于是自己实现了个系统软件盘。

    但一弹出来软键盘,对话框就被该住了!这怎么破?方法是有的。就是本文介绍的,随着软键盘的弹起自动移动位置的对话框。

    先封装实现个baseDialog基础类,把通用的操作封装一下。

    package com.newcapec.visitorsystem.dialog;
    import android.app.Dialog;
    import android.content.Context;
    import android.content.DialogInterface;
    import android.os.Build;
    import android.os.Bundle;
    import android.util.Log;
    import android.view.View;
    import android.view.Window;
    import android.view.WindowManager;
    
    /**
     * Created by yangyongzhen on 2017/5/12.
     */
    public abstract class BaseDialog<T> extends Dialog implements DialogInterface.OnDismissListener, DialogInterface.OnShowListener{
        protected View rootView;
        protected boolean isInit;
        protected Context context;
        protected boolean isFullScreen;
        protected Window window;
    
        public BaseDialog(Context context) {
            super(context);
            this.context = context;
            window = getWindow();
        }
    
        public BaseDialog(Context context, boolean isFullScreen) {
            super(context);
            this.context = context;
            this.isFullScreen = isFullScreen;
            window = getWindow();
        }
    
        public BaseDialog(Context context, int themeResId) {
            super(context, themeResId);
            this.context = context;
            window = getWindow();
           // sysApplication = (App) ((Activity)context).getApplication();
        }
    
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            //hideBottomUIMenu();
           // showBottomUIMenu();
            rootView = getBindingRoot();
            if(rootView!=null){
                setContentView(rootView);
            }else{
                setContentView(getLayoutResid());
            }
            initView();
            initData();
            initEvent();
            setOnDismissListener(this);
            setOnShowListener(this);
        }
    
        protected int getHeight() {
            return 0;
        }
    
        protected int getWidth() {
            return 0;
        }
    
        abstract View getBindingRoot();
    
        protected void initView() {
            //window.clearFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);  //清除灰色背景
        }
    
        protected int getLayoutResid() {
            return 0;
        }
    
        protected void initData() {
    
        }
    
        protected void initEvent() {
    
        }
    
        @Override
        public void onDetachedFromWindow() {
            super.onDetachedFromWindow();
            //hideBottomUIMenu();
            Log.i("Dialog", "onDetachedFromWindow");
        }
    
        @Override
        public void cancel() {
            super.cancel();
        }
    
        @Override
        public void onDismiss(DialogInterface dialog) {
            doDismiss();
        }
    
        public void doDismiss() {}
    
        /**
         * 隐藏虚拟按键:必须放到setContentView前面
         */
        protected void hideBottomUIMenu() {
            if (Build.VERSION.SDK_INT > 11 && Build.VERSION.SDK_INT < 19) {
                View v = this.getWindow().getDecorView();
                v.setSystemUiVisibility(View.GONE);
            } else if (Build.VERSION.SDK_INT >= 19) {
                View decorView = getWindow().getDecorView();
                int uiOptions = View.SYSTEM_UI_FLAG_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY | View.SYSTEM_UI_FLAG_FULLSCREEN;
                decorView.setSystemUiVisibility(uiOptions);
            }
        }
    
        protected void showBottomUIMenu() {
            //隐藏虚拟按键,并且全屏
            if (Build.VERSION.SDK_INT > 11 && Build.VERSION.SDK_INT < 19) { // lower api
                View v = this.getWindow().getDecorView();
                v.setSystemUiVisibility(View.VISIBLE);
            } else if (Build.VERSION.SDK_INT >= 19) {
                //for new api versions.
                View decorView =this.getWindow().getDecorView();
                decorView.setSystemUiVisibility(
                        View.SYSTEM_UI_FLAG_IMMERSIVE
                                | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
            }
        }
    
        @Override
        public void onShow(DialogInterface dialog) {
            if(!isInit) {
                isInit = true;
            }
        }
    
        @Override
        public void show() {
            //focusNotAle(window);
            super.show();
            //hideNavigationBar(window);
            //clearFocusNotAle(window);
        }
    
    }
    
    
    /**
     * 后屏显示的Dialog的基础类,因为后屏的Dialog的像素密度跟前屏不一样,所以需要改下像素密度才能正常显示
     * 前屏像素密度为1,后屏获取到的为2
     */
    public class BackDialog extends BaseDialog {
        private final String TAG = "BackDialog";
        public BackDialog(Context context, int themeResId){
            super(context, themeResId);
            float scale = context.getResources().getDisplayMetrics().density;
            int dp =(int) (48 / scale + 0.5f);
            Log.e(TAG,"dp:"+dp);
        }
        @Override
        View getBindingRoot() {
            //更改Dialog的像素密度
            Utils.setDensity(App.getContext(),context);
            //使背景变暗
    //        WindowManager.LayoutParams lp = getWindow().getAttributes();
    //        lp.alpha = 0.6f;
    //        getWindow().setAttributes(lp);
            //getWindow().addFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);
            return null;
        }
    
        /**
         * 禁掉系统软键盘
         */
        public void hideSoftInputMethod(EditText edit) {
            this.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
            int currentVersion = android.os.Build.VERSION.SDK_INT;
            String methodName = null;
            if (currentVersion >= 16) {
                // 4.2
                methodName = "setShowSoftInputOnFocus";
            } else if (currentVersion >= 14) {
                // 4.0
                methodName = "setSoftInputShownOnFocus";
            }
            if (methodName == null) {
                edit.setInputType(InputType.TYPE_NULL);
            } else {
                Class<EditText> cls = EditText.class;
                Method setShowSoftInputOnFocus;
                try {
                    setShowSoftInputOnFocus = cls.getMethod(methodName, boolean.class);
                    setShowSoftInputOnFocus.setAccessible(true);
                    setShowSoftInputOnFocus.invoke(edit, false);
                } catch (NoSuchMethodException e) {
                    edit.setInputType(InputType.TYPE_NULL);
                    e.printStackTrace();
                } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        }
    }

     以下是我的LoginDlg继承自基类:

    package com.newcapec.visitorsystem.dialog;
    
    import android.annotation.SuppressLint;
    import android.content.Context;
    import android.text.InputType;
    import android.util.Log;
    import android.view.Display;
    import android.view.Gravity;
    import android.view.LayoutInflater;
    import android.view.MotionEvent;
    import android.view.View;
    import android.view.Window;
    import android.view.WindowManager;
    import android.widget.Button;
    import android.widget.EditText;
    
    import com.newcapec.visitorsystem.R;
    import com.newcapec.visitorsystem.diyview.AbcNumberViewBack;
    import com.newcapec.visitorsystem.utils.Utils;
    
    
    public class LoginDlg extends BackDialog {
        private final String TAG = "LoginDlg";
    
        EditText editInputUsername,editInputPassword;
        AbcNumberViewBack abcNumberView;
        Button btnLogin;
        private OnLoginListener onLoginListener;
        //private DialogLoginBinding loginBinding;
        public LoginDlg(Context context, int themeResId, AbcNumberViewBack abcNumberViewBack){
            super(context, themeResId);
            abcNumberView = abcNumberViewBack;
        }
        @Override
        View getBindingRoot() {
            super.getBindingRoot();
            rootView = LayoutInflater.from(context).inflate(R.layout.dialog_login, null, false);
            //loginBinding = DataBindingUtil.inflate(LayoutInflater.from(context),R.layout.dialog_login,null,false);
            return rootView;
        }
        @Override
        protected void initView() {
            super.initView();
            final Window dialogWindow = this.getWindow();
            WindowManager.LayoutParams lp1 = dialogWindow.getAttributes();
            lp1.width = Utils.dp2px(910); //设置宽度
            lp1.height = Utils.dp2px(660); //设置高度
            //lp1.width = width;
            //lp1.height = height;
            dialogWindow.setAttributes(lp1);
            dialogWindow.clearFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);  //清除灰色背景
            editInputUsername = findViewById(R.id.edit_login_username);
            editInputPassword = findViewById(R.id.edit_login_password);
            btnLogin = findViewById(R.id.btn_login);
        }
    
        @Override
        protected void initData() {
            super.initData();
            initTouch();
            btnLogin.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    Log.d(TAG,"btn login click:");
                    abcNumberView.hideKeyboard();
                    resetPosition(0,0,Gravity.CENTER);
                    if(onLoginListener != null){
                        onLoginListener.onClickLogin(editInputUsername.getText().toString(),editInputPassword.getText().toString());
                    }
                    //dismiss();
                }
            });
            //KeyBoardUtils.openKeybord(editInputUsername,context);
        }
    
        /**
         * 重新设置Dialog的显示位置
         */
        protected void resetPosition(int x,int y,int gravity){
            Window mWindow = getWindow();
            mWindow .setGravity(gravity);
            WindowManager.LayoutParams lp = mWindow.getAttributes();
            lp.x = x; // 新位置X坐标
            lp.y = y; // 新位置Y坐标
            onWindowAttributesChanged(lp);
        }
    
        @Override public void show(){
            super.show();
        }
    
        @Override public void dismiss(){
            editInputUsername.setText("");
            editInputPassword.setText("");
            super.dismiss();
        }
    
        @SuppressLint("ClickableViewAccessibility")
        private void initTouch() {
            //初始化键盘监听
            hideSoftInputMethod(editInputUsername);
            editInputUsername.setOnTouchListener(new View.OnTouchListener() {
                @Override
                public boolean onTouch(View view, MotionEvent event) {
                    Log.e(TAG, "键盘--------" + event.getAction());
                    abcNumberView.setmEdit(editInputUsername);
                    if (event.getAction() == MotionEvent.ACTION_UP) {
                        if (view != null) {
                            resetPosition(0,0,Gravity.TOP);
                            if (!abcNumberView.isShow()) {
                                abcNumberView.showKeyboard();
                            }
                        }
                    }
                    return false;
                }
            });
            hideSoftInputMethod(editInputPassword);
            editInputPassword.setOnTouchListener(new View.OnTouchListener() {
                @Override
                public boolean onTouch(View view, MotionEvent event) {
                    Log.e(TAG, "键盘--------" + event.getAction());
                    abcNumberView.setmEdit(editInputPassword);
                    if (event.getAction() == MotionEvent.ACTION_UP) {
                        if (view != null) {
                            resetPosition(0,0,Gravity.TOP);
                            if (!abcNumberView.isShow()) {
                                abcNumberView.showKeyboard();
                            }
                        }
                    }
                    return false;
                }
            });
    
            abcNumberView.setOkListener(new AbcNumberViewBack.OnOkListener() {
                @Override
                public void onOk(String e) {
                    resetPosition(0,0,Gravity.CENTER);
                }
            });
        }
    
    
        public interface OnLoginListener {
            void onClickLogin(String name,String pwd);//点击了确认
        }
    
        public void setOnLoginListener(OnLoginListener onLoginListener) {
            this.onLoginListener = onLoginListener;
        }
    }
    

    自动移动位置的秘诀:

     /**
         * 重新设置Dialog的显示位置
         */
        protected void resetPosition(int x,int y,int gravity){
            Window mWindow = getWindow();
            mWindow .setGravity(gravity);
            WindowManager.LayoutParams lp = mWindow.getAttributes();
            lp.x = x; // 新位置X坐标
            lp.y = y; // 新位置Y坐标
            onWindowAttributesChanged(lp);
        }

     

    展开全文
  • Windows 使用键盘移动窗口

    万次阅读 2019-03-05 21:22:35
    Windows 使用键盘移动窗口 有时博主手一抖,就把应用程序的窗口拖到桌面外面了……只能关了再开。 所以本文介绍,如何使用键盘控制窗口移动。 Step1. 快捷键 Alt + Space 点击任务栏中要操作的应用程序,按下...

    Windows 使用键盘移动窗口


    有时手一抖,一不小心就把应用程序的窗口拖到桌面外面了……只能关了再开。

    所以本文介绍,如何使用键盘控制窗口移动,将应用移回桌面。


    Step1. 快捷键 Alt + Space

    点击任务栏中要操作的应用程序,按下快捷键 Alt + Space,便可以开启一个菜单(下图仅供演示):
    menu

    Step2. 键盘控制

    使用键盘方向键加回车,或直接按对应字母,便可使用对应功能。

    我们使用 “移动” 功能,便可以用方向键控制窗口移动了(若窗口已经最大化,则需先使用 “还原” 功能)。

    Others

    也有一些应用屏蔽了 Alt + Space 快捷菜单(例如网易云音乐 Win32 版)。对于这些应用,可以使用 Win + 方向键 将其拖回桌面(仅限 Windows 10)。

    展开全文
  • 对话框程序设计中,Windows内置的对话框管理器为我们提供了常用的键盘操作支持,它包括子窗口控件的Tab停留和分组, 子窗口...对Enter,Esc和Ctrl+Break的处理支持,用于使用键盘快速关闭对话框1.Tab停留在对话框中,
  • MFC 对话框Dialog响应键盘事件

    千次阅读 2017-01-08 10:08:11
    对话框程序中有时需要响应键盘和鼠标事件,MFC的对话框继承于CWnd窗口类,总结了如下几种可能的处理方式: 1,最直观的想法是重写类中的虚拟响应函数,这些响应函数有: 键盘相关:ON_WM_CHAR、ON_WM_KWEYDOWN、ON...
  •  ...•图形的方式,来显示计算机操作的界面,这样更方便更直观。   Java为GUI提供的对象都存在java.Awt和javax.Swing两个包中。 java.Awt: Abstract Window ToolKit (抽象窗口工具包
  • 对话框

    千次阅读 2011-05-03 15:51:00
    对话框是一种用户界面,它的主要功能是输出信息和接收用户的输入。对话框与控件是密不可分的,在每个对话框内一般都有一些控件,对话框依靠这些控件与用户进行交互.一个典型的对话框例子是选择了File-Open命令后弹...
  • 对话框响应鼠标/键盘消息

    千次阅读 2011-10-20 16:38:37
    WM_MOUSEMOVE 鼠标移动位置 WM_LBUTTONDOWN 鼠标左键按下 WM_LBUTTONUP 鼠标左键弹起 WM_LBUTTONDBLCLK 鼠标左键双击 WM_RBUTTONDOWN 鼠标右键按下 WM_RBUTTONUP 鼠标右键弹起 WM_RBUTTONDBLCLK 鼠标右键双击 ...
  • 1.新建一个MFC基于对话框的工程,在对话框上插入图像控件。然后在图像控件上绘制一个绿色的矩形。绘制矩形代码如下: (1)dlg类添加成员变量 CRect类型的变量 m_rect此变量用来保存矩形的四个坐标点。在dlg类的构造...
  • 10.对话框响应鼠标及键盘消息

    千次阅读 2011-08-25 10:26:26
    ①、各种各样的常用鼠标消息: ...WM_MOUSEMOVE 鼠标移动位置 WM_LBUTTONDOWN 鼠标左键按下 WM_LBUTTONUP 鼠标左键弹起 WM_LBUTTONDBLCLK 鼠标左键双击 WM_RBUTTONDOWN 鼠标右键按下 WM_RB
  • MFC对话框应用

    2012-04-26 15:40:28
    一个小MFC应用程序, 1.用键盘移动窗口的字符。 2.为鼠标左键单击消息WM_LBUTTONDOWN和鼠标右键双击消息WM_RBUTTONDBLCLK添加相应消息映射函数。 3.设置鼠标形状。 4.限定鼠标的移动范围。
  • WIN32汇编对话框使用

    千次阅读 2016-03-25 20:09:36
    刚开始接触windows下的对话框,第一感觉就像是一个一般的窗口一样,没有图标,只有一个框框,中间有一些提示的控件(按钮,输入的文本框等)信息,在学习使用对话框的时候,资源文件的编写我感觉比编写实现对话框的...
  • MFC 对话框

    千次阅读 2013-10-30 15:15:47
    对话框由一个rc资源文件描述外观,通过ID与一个CPP类相连接,对话框内的控件使用基于ID的变量映射通讯。 模式对话框对象被定义后,通过调用DoModal()函数来显示对话框并进行相关操作,此函数当对话框被关闭时返回。...
  • 对话框概述

    2007-07-30 10:29:00
    对话框和对话框类CDialog 对话框经常被使用,因为对话框可以从模板创建,而对话框模板是可以使用资源编辑器方便地进行编辑的。 模式和无模式对话框 对话框分两种类型,模式对话框和无模式对话框。 模式对话框
  • 编写程序,实现使用键盘上的上下左右箭头控制界面上图片的移动
  • MFC基于对话框,在对话框上插入图像控件,在图像控件上,画一个绿色的矩形,按键盘上下左右键,矩形在图像控件上移动移动。分别创建一个文本文件和一个二进制文件,对话框退出时,文档内写入保存退出前的矩形的位置...
  • VC对话框使用技巧

    2013-07-28 09:19:24
    1. 在任务栏隐藏对话框 ModifyStyleEx(WS_EX_APPWINDOW, WS_EX_TOOLWINDOW); 2. 使对话框为顶层窗口 SetWindowPos(&this->wndTopMost, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE); 3. 在运行时添加最大化,...
  • 请按 目的 Ctrl + Tab 在选项卡之间向前移动。 Ctrl + Shift +Tab 在选项卡之间向后移动。 Tab 在选项之间向前移动。 Shift + Tab 在选项...
  • 头文件 ...// CMFC_ShowPointDlg 对话框 class CMFC_ShowPointDlg : public CDialogEx { // 构造 public: CMFC_ShowPointDlg(CWnd* pParent = NULL); // 标准构造函数 // 对话框数据 e...
  • 如何用键盘控制windows窗口移动

    千次阅读 2019-08-27 11:04:01
    有时候某个窗口的可拖动边框被移动到桌面外了,怎么把它给整回来? 1、底部任务栏选中该窗口,或者alt+tab选中该窗口 2、alt+space后按m键 3、通过上下左右键移动窗口 ...
  • MFC对话框

    2012-05-04 12:00:20
    MS的指示:非模态对话框需要重载函数OnCanel,并且在这个函数中调用...还有一个必须重载的函数就是PostNcDestroy,这也是一个虚函数,通常的非模态对话框类的指针,通过new创建的,这就需要在PostNcDestroy函数中
  • MFC模态对话框与非模态对话框

    千次阅读 2015-08-06 12:25:47
    对话框经常被使用,因为对话框可以从模板创建,而对话框模板是可以使用资源编辑器方便地进行编辑的。 一,模态与非模态对话框 1.模态对话框  一个模态对话框是一个有系统菜单、标题栏、边线等的弹出式窗口。在...
  • MFC模态对话框和非模态对话框

    千次阅读 多人点赞 2018-09-11 15:30:54
    下面是一个我的手写的模态对话框和非模态对话框图: 模态对话框是指当其显示时,程序会暂停执行,直到关闭这个模态对话框后,才能继续执行程序中其他任务。非模态对话框是指当其显示时,允许转而执行程序中其他...
  • 11.1 模态对话框

    2015-11-16 17:04:53
     对话框分“模态”和“非模态”两种,其中模态对话框最为常见。当程序显示一个模态对话框时,用户不能在对话框和该程序的其他窗口之间进行切换。用户必须先明确地终止该对话框。这通常由单击 OK 或 Cancel 按钮来...
  • //键盘方向键每响应一次的图像移动的像素单位上的步长 int dirct; //用于标记那个方向键按下。1:左,2:右,3:上,4:下,5:delete(删除) // 生成的消息映射函数 virtual BOOL OnInitDialog(); afx_msg...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,725
精华内容 18,290
关键字:

如何用键盘移动对话框