tao 0.30.0

Cross-platform window manager library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use std::sync::Once;

use cocoa::{
  base::{id, nil},
  foundation::{NSArray, NSPoint, NSRect, NSSize},
};
use objc::{
  declare::ClassDecl,
  runtime::{Class, Object, Sel, NO},
};

use crate::window::{ProgressBarState, ProgressState};

/// Set progress indicator in the Dock.
pub fn set_progress_indicator(progress_state: ProgressBarState) {
  unsafe {
    let ns_app: id = msg_send![class!(NSApplication), sharedApplication];
    let dock_tile: id = msg_send![ns_app, dockTile];
    if dock_tile == nil {
      return;
    }

    // check progress indicator is already set or create new one
    let progress_indicator: id = get_exist_progress_indicator(dock_tile)
      .unwrap_or_else(|| create_progress_indicator(ns_app, dock_tile));

    // set progress indicator state
    if let Some(progress) = progress_state.progress {
      let progress = progress.clamp(0, 100) as f64;
      let _: () = msg_send![progress_indicator, setDoubleValue: progress];
      let _: () = msg_send![progress_indicator, setHidden: NO];
    }
    if let Some(state) = progress_state.state {
      (*progress_indicator).set_ivar("state", state as u8);
      let _: () = msg_send![
        progress_indicator,
        setHidden: matches!(state, ProgressState::None)
      ];
    }

    let _: () = msg_send![dock_tile, display];
  }
}

fn create_progress_indicator(ns_app: id, dock_tile: id) -> id {
  unsafe {
    let mut image_view: id = msg_send![dock_tile, contentView];
    if image_view == nil {
      // create new dock tile view with current app icon
      let app_icon_image: id = msg_send![ns_app, applicationIconImage];
      image_view = msg_send![class!(NSImageView), imageViewWithImage: app_icon_image];
      let _: () = msg_send![dock_tile, setContentView: image_view];
    }

    // create custom progress indicator
    let dock_tile_size: NSSize = msg_send![dock_tile, size];
    let frame = NSRect::new(
      NSPoint::new(0.0, 0.0),
      NSSize::new(dock_tile_size.width, 15.0),
    );
    let progress_class = create_progress_indicator_class();
    let progress_indicator: id = msg_send![progress_class, alloc];
    let progress_indicator: id = msg_send![progress_indicator, initWithFrame: frame];
    let _: () = msg_send![progress_indicator, autorelease];

    // set progress indicator to the dock tile
    let _: () = msg_send![image_view, addSubview: progress_indicator];

    progress_indicator
  }
}

fn get_exist_progress_indicator(dock_tile: id) -> Option<id> {
  unsafe {
    let content_view: id = msg_send![dock_tile, contentView];
    if content_view == nil {
      return None;
    }
    let subviews: id /* NSArray */ = msg_send![content_view, subviews];
    if subviews == nil {
      return None;
    }

    for idx in 0..subviews.count() {
      let subview: id = msg_send![subviews, objectAtIndex: idx];

      let is_progress_indicator: bool =
        msg_send![subview, isKindOfClass: class!(NSProgressIndicator)];
      if is_progress_indicator {
        return Some(subview);
      }
    }
  }
  None
}

fn create_progress_indicator_class() -> *const Class {
  static mut APP_CLASS: *const Class = 0 as *const Class;
  static INIT: Once = Once::new();

  INIT.call_once(|| unsafe {
    let superclass = class!(NSProgressIndicator);
    let mut decl = ClassDecl::new("TaoProgressIndicator", superclass).unwrap();

    decl.add_method(
      sel!(drawRect:),
      draw_progress_bar as extern "C" fn(&Object, _, NSRect),
    );

    // progress bar states, follows ProgressState
    decl.add_ivar::<u8>("state");

    APP_CLASS = decl.register();
  });

  unsafe { APP_CLASS }
}

extern "C" fn draw_progress_bar(this: &Object, _: Sel, rect: NSRect) {
  unsafe {
    let bar = NSRect::new(
      NSPoint { x: 0.0, y: 4.0 },
      NSSize {
        width: rect.size.width,
        height: 8.0,
      },
    );
    let bar_inner = bar.inset(0.5, 0.5);
    let mut bar_progress = bar.inset(1.0, 1.0);

    // set progress width
    let current_progress: f64 = msg_send![this, doubleValue];
    let normalized_progress: f64 = (current_progress / 100.0).clamp(0.0, 1.0);
    bar_progress.size.width *= normalized_progress;

    // draw outer bar
    let bg_color: id = msg_send![class!(NSColor), colorWithWhite:1.0 alpha:0.05];
    let _: () = msg_send![bg_color, set];
    draw_rounded_rect(bar);
    // draw inner bar
    draw_rounded_rect(bar_inner);

    // draw progress
    let state: u8 = *(this.get_ivar("state"));
    let progress_color: id = match state {
      x if x == ProgressState::Paused as u8 => msg_send![class!(NSColor), systemYellowColor],
      x if x == ProgressState::Error as u8 => msg_send![class!(NSColor), systemRedColor],
      _ => msg_send![class!(NSColor), systemBlueColor],
    };
    let _: () = msg_send![progress_color, set];
    draw_rounded_rect(bar_progress);
  }
}

fn draw_rounded_rect(rect: NSRect) {
  unsafe {
    let raduis = rect.size.height / 2.0;
    let bezier_path: id =
      msg_send![class!(NSBezierPath), bezierPathWithRoundedRect:rect xRadius:raduis yRadius:raduis];
    let _: () = msg_send![bezier_path, fill];
  }
}