Hello sir. I always have questions. It seems that the program controlled item selection in TreeView is invalid unless the TreeView is focused. And another problem is , the previous selection is not cleared when I try to select new items. How to tackle these two problems? Thanks for your coming help.

There are few aspects that you can improve in clipboard:

• Use IsClipboardFormatAvailable to determine if format is available which can be used without clipboard open
• Check for failure SetClipboardData - if it fails you need to free memory
• Use MultiByteToWideChar to efficiently write encoded string onto allocated memory instead of using intermediate allocation (and then append 0)

You can use my code in clipboard-win as reference if you want something more

I'm trying to the add listview support. But failed. Can you test my fork? https://github.com/zoumi/native-windows-gui The problem is: 1,after add the listview to the window , all the control will blink 2,can't add the full string to listview cell.(If i add "what is this" it will show "xhat is this")

Here is the code to test the listview:

//#![windows_subsystem = "windows"]
//#![feature(link_args)]
//#[link_args = "-Wl,--subsystem,windows"]
//#[link_args = "/SUBSYSTEM:WINDOWS"]
#[macro_use] extern crate native_windows_gui as nwg;

use nwg::{Event, Ui, simple_message, fatal_message, dispatch_events};
extern crate winapi;
use winapi::{LPCWSTR,HWND};

extern "system"{
pub fn SetWindowTheme(hwnd: HWND,
                      pszSubAppName: LPCWSTR,
                      pszSubIdList: LPCWSTR);
}

/// Custom enums are the preferred way to define ui ids. 
/// It's clearer and more extensible than any other types (such as &'str).
#[derive(Debug, Clone, Hash)]
pub enum AppId {
    // Controls
    MainWindow,
    NameInput, 
    HelloButton,
    Label(u8),   // Ids for static controls that won't be referenced in the Ui logic can be shortened this way.
    MyListView,

    // Events
    SayHello,

    // Resources
    MainFont,
    TextFont
}

use AppId::*; // Shortcut

nwg_template!(
    head: setup_ui<AppId>,
    controls: [
        (MainWindow, nwg_window!( title="Template Example"; size=(280, 305) )),
        (Label(0), nwg_label!(
             parent=MainWindow;
             text="Your Name: ";
             position=(5,15); size=(80, 25);
             font=Some(TextFont) )),

        (NameInput, nwg_textinput!( 
             parent=MainWindow; 
             position=(85,13); size=(185,22); 
             font=Some(TextFont) )),

        (HelloButton, nwg_button!( 
             parent=MainWindow; 
             text="Hello World!"; 
             position=(5, 45); size=(270, 50); 
             font=Some(MainFont) )),

        (MyListView, nwg_list_view!(
                parent=MainWindow;
                text="oh my list view";
                position=(5,100);size=(270,200);
                font=Some(MainFont) ))
    ];

    events: [
        (HelloButton, SayHello, Event::Click, |ui,_,_,_| {

            let my_list_view = nwg_get!(ui; (MyListView,nwg::ListView));
           // unsafe { SetWindowTheme}
            my_list_view.insert_col(0,"FIRST",50);
            my_list_view.insert_col(1,"wsec",50);
            my_list_view.insert_col(2,"wtrd",50);
            my_list_view.add(vec!["1fsafas".to_owned(),"ewheh2".to_owned(),"3sfsaga".to_owned()]);
            my_list_view.insert(1,
                vec!["1o8u53b".to_owned(),"iluou2".to_owned(),"3wvrwr".to_owned()]);
            my_list_view.insert(2,
                vec!["1333".to_owned(),"266666".to_owned(),"00003".to_owned()]);
            println!("list_view hwnd: {:?}",my_list_view);
            //let your_name = nwg_get!(ui; (NameInput, nwg::TextInput));
            //simple_message("Hello", &format!("Hello {}!", your_name.get_text()) );
        }),
        (MyListView, SayHello, Event::Notify, |ui,hwnd,wpara,lpara| {
        
        })
    ];
    resources: [
        (MainFont, nwg_font!(family="Arial"; size=27)),
        (TextFont, nwg_font!(family="Arial"; size=17))
    ];
    values: []
);

fn main() {
    let app: Ui<AppId>;

    match Ui::new() {
        Ok(_app) => { app = _app; },
        Err(e) => { fatal_message("Fatal Error", &format!("{:?}", e) ); }
    }

    if let Err(e) = setup_ui(&app) {
        //fatal_message("Fatal Error", &format!("{:?}", e));
    }


    dispatch_events();
}

In the application I have developed with native-windows-gui, the mouse cursor flickers between Normal and IBeam when positioned over a RichLabel element. It also flickers between Normal and one of the Size cursors when positioned over the window border (if the window is resizable).

In the case of RichLabel, I can workaround this by implementing a handler for WM_SETCURSOR but I do find it strange that the cursor is modified for RichLabel elements and no others.

I have been unable to workaround the flickering for the border. I suspect the flickering may be because Window specifies a cursor when instantiating WNDCLASSEXW. I've tried setting the cursor myself in my WM_SETCURSOR handler, and I've also tried calling DefWindowProcA from the handler.

Basic support for nested flexboxes, mostly through changing style modification style (unification between item and layout subitems).

This required adding a new child_layout functionality to prevent sub-layouts from registering their own callbacks. Sublayout are thus only recalculated when the parent layout is recalculated.

Happy to change or explain anything if required!

Minimal changes in API were required. Added additional reference inside ImageSource. ImageSource and ImageData are now wrapped in LifetimeRef. It didn't change much, since it implements deref. Also they usually don't require mutation and are local.

This allows a flexible dynamic UI. I think adding the children to the FlexboxLayout is merely taking out the children Control of the child FlexboxLayout and add it on the parent FlexboxLayout, I'm not sure though. I'm also surprise that the underlying windows UI doesn't actually have a native layout support. So, the higher level UI frameworks will have to calculate them.

Take note also, that the stretch layout computation is calculating the location of each children relative to the parent container. So, to put the child component in their absolute position, I have to add the parent location to each of the child location after the layout computation.

Hey,

Started using this fantastic library today and I'm missing a few things that would be neat. One of them is being able to set a placeholder text for text inputs.

I believe it can be accomplished with:

https://docs.microsoft.com/en-us/windows/win32/controls/em-setcuebanner

But I'm not sure if it's viable to use it because of the note:

To use this API, you must provide a manifest specifying Comclt32.dll version 6.0

What do you think?

Thanks!

Instead of setting parent, we can use nesting:

let main_window = Window {
    caption: "Hello".to_string(),
    size: (200, 200),
    position: (100, 100),
    visible: true,
    resizable: false,
    exit_on_close: true,
    children: vec![
      TextInput {
          name: "Name",
          text: "".to_string(),
          size: (180, 20),
          position: (10, 10),
          placeholder: Some("Your name Here".to_string()),
          text_align: HTextAlign::Left,
          password: false,
          readonly: false
      },
      Button {
          text: "Say Hello!".to_string(),
          size: (180, 130),
          position: (10, 50),
          text_align: (HTextAlign::Center, VTextAlign::Center),
          on_click: Box::new(|ui, caller|{
              println!("Caller is: {:?}", caller);
              if let Ok(ActionReturn::Text(name)) = ui.exec("Name", Action::GetText) {
                  let msg = actions_help::message(
                      "Hello!", format!("Hello {}!", name),
                      MessageButtons::Ok, MessageIcons::None
                  );
                  ui.exec("MainWindow", msg).unwrap();
              }
        })
      }
    ]
};
main_window.run();

Please take a look at https://github.com/lxn/walk and borrow some ideas from there.

https://github.com/gabdube/native-windows-gui/blob/1.0-prerelease/native-windows-gui/src/layouts/box_layout.rs#L237

            let local_width = (_item_width * item.span) + (sp2 * (item.span - 1));
            let local_height = (_item_height * item.span) + (sp2 * (item.span - 1));

My understand is that Box (such as in Gtk) should be able to accommodate the children content independent on the size of the cells. It looks like the BoxLayout in nwg is implemented in the assumption that the cells must have the same sizes.

Is this something we could change the behavior of BoxLayout or is there an alternative control should I be using instead.

First off, let me say I am a beginner in Rust and to this library so there might be an easy solution to this.

I've been trying to bind a raw event handler, which will allow me to capture the WM_HOTKEY event globally for whenever a given hotkey I've registered with RegisterHotKey. I want this hotkey to be captured even if the focused HWND doesn't belong to my process.

This is what my code looks like right now:

pub fn register_hotkey() {
  unsafe {
    RegisterHotKey(
      HWND::NULL,
      CUSTOM_HANDLER_ID as i32,
      MOD_CONTROL | MOD_SHIFT,
      'X' as u32,
    );
  };
}

And to register the raw event handler:

 let raw_handler = bind_raw_event_handler(
        &ui.window.handle,
        CUSTOM_HANDLER_ID ,
        |_hwnd, msg, _w, l| {
          match msg {
            WM_HOTKEY => {
              println!("Hotkey called");
            }
            _ => {
              println!("Some other evt")
            }
          }

          None
        },
      );

My problem is that although the raw handler is registered fine (I do get console output for the "Some other evt" line which is capture-all), I cannot get my registered hotkey to trigger.

I took a look at the source code and I saw that in the implementation of pub fn dispatch_thread_events there's a check for IsDialogMessageW (https://github.com/gabdube/native-windows-gui/blob/d0ab1cdacd83b73572907e5f064a4c3a02458e99/native-windows-gui/src/win32/mod.rs#L49)

Could it be that my event is not fired because of this check?

Thank you in advance for the time taken to look at the question :)

It was weird that I couldn't make one of the filters the default option.

Prior to this change, the first filter is always the default. Now, the filter prefixed with > is the default.

I chose > because you can't name a file with it.

Here's a file dialog with the filter string PNG(*.png)|JPEG(*.jpg;*.jpeg)|WebP(*.webp)|>Supported image files(*.png;*.jpg;*.jpeg;*.webp):

Just like a parent (HWND) can have multiple timers, it can have multiple notification area icons (TrayNotifications) differentiated by an ID. Use similar functionality as with timers to extend support to multiple icons per parent.

The Shell_NotifyIconW(NIM_SETVERSION, &mut data); call is necessary to ensure that the icon ID is passed in the expected format to process_events(...), as the version field is ignored otherwise (well, interpreted as the timeout value). This has been previously pointed out by @iquanxin in issue #246.

When explorer.exe crashes or restarts the icon disappears from the system tray. This happens on Windows 11 using rust stable-x86_64-pc-windows-msvc 1.63.0.

Steps to reproduce: Run either system_tray example

• cargo run --example system_tray --features "tray-notification message-window menu cursor"
• cargo run --example system_tray_d --features "tray-notification message-window menu cursor"

Then open Task Manager to the Processes tab and find "Windows Explorer" and right click and then select "restart"

After a few seconds the taskbar will reload and when you navigate to the system tray area the icon for the system_tray app will be gone but the application will still be running(you can see the process exe is still running if you look at Task Manager). No output is shown on the terminal you run the example from.

Currently, when switching from and then back to an NWG application window the keyboard focus isn't given to the control it was previously on. Instead, it always goes to the parent window.

pub fn builder<'a>() -> WindowBuilder<'a> {
        WindowBuilder {
            title: "New Window",
            size: (500, 500),
            position: (300, 300),
            accept_files: false,
            topmost: false,
            center: false,
            maximized: false,
            minimized: false,
            flags: None,
            ex_flags: 0,
            icon: None,
            parent: None
        }

When setting center=true, the window will display the default position first. Then jump to the center position, and the generated window will move, It's a bad experience. It is recommended that the screen be centered by default.