Only show op actions in context menu when user is an op.

src/buffer/channel.rs

@@ -34,6 +34,11 @@ pub fn view<'a>(
     let input = history.input(&buffer);
     let our_nick = clients.nickname(&state.server);
 
+    let users = clients.get_channel_users(&state.server, &state.channel);
+    let our_user = users
+        .iter()
+        .find(|user| user.nickname() == our_nick.unwrap());
+
     let messages = container(
         scroll_view::view(
             &state.scroll_view,
@@ -52,17 +57,17 @@ pub fn view<'a>(
                 match message.target.source() {
                     message::Source::User(user) => {
                         let nick = user_context::view(
-                            selectable_text(config.buffer.nickname.brackets.format(user)).style(
-                                |theme| {
+                            selectable_text(config.buffer.nickname.brackets.format(user))
+                                .style(|theme| {
                                     theme::selectable_text::nickname(
                                         theme,
                                         user.color_seed(&config.buffer.nickname.color),
                                         user.is_away(),
                                     )
-                                },
-                            ),
+                                }),
                             user,
                             state.buffer(),
+                            our_user,
                         )
                         .map(scroll_view::Message::UserContext);
 
@@ -118,22 +123,20 @@ pub fn view<'a>(
     .width(Length::FillPortion(2))
     .height(Length::Fill);
 
-    let is_connected_to_channel = clients
-        .get_channels(&state.server)
-        .iter()
-        .any(|c| c == &state.channel);
-    let users = clients.get_channel_users(&state.server, &state.channel);
-    let channels = clients.get_channels(&state.server);
-    let nick_list = nick_list::view(users, &buffer, config).map(Message::UserContext);
+    let nick_list = nick_list::view(users, &buffer, our_user, config).map(Message::UserContext);
+
+    // If topic toggles from None to Some then it messes with messages' scroll state,
+    // so produce a zero-height placeholder when topic is None.
+    let topic = topic(state, clients, users, our_user, settings, config)
+        .unwrap_or_else(|| column![].into());
 
     let show_text_input = match config.buffer.input_visibility {
         data::buffer::InputVisibility::Focused => is_focused,
         data::buffer::InputVisibility::Always => true,
     };
 
-    // If topic toggles from None to Some then it messes with messages' scroll state,
-    // so produce a zero-height placeholder when topic is None.
-    let topic = topic(state, clients, users, settings, config).unwrap_or_else(|| column![].into());
+    let channels = clients.get_channels(&state.server);
+    let is_connected_to_channel = channels.iter().any(|c| c == &state.channel);
 
     let text_input = show_text_input.then(move || {
         input_view::view(
@@ -248,6 +251,7 @@ fn topic<'a>(
     state: &'a Channel,
     clients: &'a data::client::Map,
     users: &'a [User],
+    our_user: Option<&'a User>,
     settings: &'a channel::Settings,
     config: &'a Config,
 ) -> Option<Element<'a, Message>> {
@@ -265,6 +269,7 @@ fn topic<'a>(
             config.buffer.channel.topic.max_lines,
             users,
             &state.buffer(),
+            our_user,
             config,
         )
         .map(Message::UserContext),
@@ -284,6 +289,7 @@ mod nick_list {
     pub fn view<'a>(
         users: &'a [User],
         buffer: &Buffer,
+        our_user: Option<&'a User>,
         config: &'a Config,
     ) -> Element<'a, Message> {
         let column = column(users.iter().map(|user| {
@@ -295,7 +301,7 @@ mod nick_list {
                 )
             });
 
-            user_context::view(content, user, buffer.clone())
+            user_context::view(content, user, buffer.clone(), our_user)
         }))
         .padding(4)
         .spacing(1);

src/buffer/channel/topic.rs

@@ -15,6 +15,7 @@ pub fn view<'a>(
     max_lines: u16,
     users: &'a [User],
     buffer: &Buffer,
+    our_user: Option<&'a User>,
     config: &'a Config,
 ) -> Element<'a, user_context::Message> {
     let set_by = who.and_then(|who| {
@@ -31,6 +32,7 @@ pub fn view<'a>(
                 }),
                 user,
                 buffer.clone(),
+                our_user,
             )
         } else {
             selectable_text(who)

src/buffer/query.rs

@@ -58,6 +58,7 @@ pub fn view<'a>(
                             ),
                             user,
                             state.buffer(),
+                            None,
                         )
                         .map(scroll_view::Message::UserContext);
 

src/buffer/user_context.rs

@@ -14,14 +14,20 @@ enum Entry {
 }
 
 impl Entry {
-    fn list(buffer: &Buffer) -> Vec<Self> {
+    fn list(buffer: &Buffer, our_user: Option<&User>) -> Vec<Self> {
         match buffer {
-            Buffer::Channel(_, _) => vec![
-                Entry::Whois,
-                Entry::Query,
-                Entry::ToggleAccessLevelOp,
-                Entry::ToggleAccessLevelVoice,
-            ],
+            Buffer::Channel(_, _) => {
+                if our_user.is_some_and(|u| u.has_access_level(data::user::AccessLevel::Oper)) {
+                    vec![
+                        Entry::Whois,
+                        Entry::Query,
+                        Entry::ToggleAccessLevelOp,
+                        Entry::ToggleAccessLevelVoice,
+                    ]
+                } else {
+                    vec![Entry::Whois, Entry::Query]
+                }
+            }
             Buffer::Server(_) | Buffer::Query(_, _) => vec![Entry::Whois],
         }
     }
@@ -56,8 +62,9 @@ pub fn view<'a>(
     content: impl Into<Element<'a, Message>>,
     user: &'a User,
     buffer: Buffer,
+    our_user: Option<&'a User>,
 ) -> Element<'a, Message> {
-    let entries = Entry::list(&buffer);
+    let entries = Entry::list(&buffer, our_user);
 
     let content = button(content)
         .padding(0)