Coverage for src/robotide/ui/actiontriggers.py: 79%

1# Copyright 2008-2015 Nokia Networks 

2# Copyright 2016- Robot Framework Foundation 

3# 

4# Licensed under the Apache License, Version 2.0 (the "License"); 

5# you may not use this file except in compliance with the License. 

6# You may obtain a copy of the License at 

7# 

8# http://www.apache.org/licenses/LICENSE-2.0 

9# 

10# Unless required by applicable law or agreed to in writing, software 

11# distributed under the License is distributed on an "AS IS" BASIS, 

12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 

13# See the License for the specific language governing permissions and 

14# limitations under the License. 

15 

16import builtins 2 ctx1ad

17import wx 2 ctx1ad

18 

19from ..context import IS_WINDOWS, IS_MAC 2 ctx1ad

20_ = wx.GetTranslation # To keep linter/code analyser happy 2 ctx1ad

21builtins.__dict__['_'] = wx.GetTranslation 2 ctx1ad

22 

23ID_CustomizeToolbar = wx.ID_HIGHEST + 1 2 ctx1ad

24 

25 

26def accel_index(menu: list, item: str) -> int: 2 ctx1ad

27 """ Gets the index from a list ignoring the accelarator marker, & 

28 :param menu: list - list to get index 

29 :param item: str - item to find in menu list 

30 :returns index: int 

31 """ 

32 for idx, m in enumerate(menu): 32 ↛ 35line 32 didn't jump to line 35 because the loop on line 32 didn't complete(empty)

33 if m.replace('&', '') == item.replace('&', ''): (empty)

34 return idx (empty)

35 raise ValueError(f"{item} is not in list") 

36 

37 

38class MenuBar(object): 2 ctx1ad

39 

40 def __init__(self, frame): 2 ctx1ad

41 self._mb = wx.MenuBar() (empty)

42 self._name_builder = _NameBuilder() (empty)

43 self.m_frame = frame (empty)

44 self._accelerators = [] (empty)

45 self._menus = [] (empty)

46 self._create_default_menus() (empty)

47 

48 def take_menu_bar_into_use(self): 2 ctx1ad

49 """This should be called after fully populating menus, 

50 Otherwise help menu will not be functional in osx.""" 

51 self.m_frame.SetMenuBar(self._mb) (empty)

52 

53 def _create_default_menus(self): 2 ctx1ad

54 for name in [_('File'), _('Edit'), _('Tools'), _('Help')]: (empty)

55 self._create_menu(name, before_help=False) (empty)

56 

57 def _create_menu(self, name, before_help=True): 2 ctx1ad

58 # print(f"DEBUG: actiontriggers.py _create_menu ENTER name={name}") 

59 menu = _Menu(self._name_builder.get_name(name), self.m_frame) (empty)

60 self._insert_menu(menu, before_help) (empty)

61 return menu (empty)

62 

63 def _insert_menu(self, menu, before_help): 2 ctx1ad

64 if before_help: (empty)

65 index = accel_index([m.name for m in self._menus], _('Help')) (empty)

66 else: 

67 index = len(self._menus) (empty)

68 self._menus.insert(index, menu) (empty)

69 self._mb.Insert(index, menu.wx_menu, menu.name) (empty)

70 

71 def register(self, action): 2 ctx1ad

72 menu = self._find_menu(action.menu_name) 3 ctx1abc

73 if not menu: 3 ctx1abc

74 menu = self._create_menu(action.menu_name) (empty)

75 menu.add_menu_item(action) 3 ctx1abc

76 

77 def _find_menu(self, name): 2 ctx1ad

78 t_name = name.replace('&', '') 3 ctx1abc

79 t_registered = self._name_builder.get_registered_name(_(t_name)) 3 ctx1abc

80 registered = self._name_builder.get_registered_name(name) 3 ctx1abc

81 if not t_registered and not registered: 3 ctx1abc

82 return None (empty)

83 if t_registered: 83 ↛ 85line 83 didn't jump to line 85 because the condition on line 83 was always true3 ctx1abc

84 registered = t_registered 3 ctx1abc

85 for menu in self._menus: 85 ↛ exitline 85 didn't return from function '_find_menu' because the loop on line 85 didn't complete3 ctx1abc

86 if menu.name == registered: 3 ctx1abc

87 return menu 3 ctx1abc

88 

89 

90class _Menu(object): 2 ctx1ad

91 

92 def __init__(self, name, frame): 2 ctx1ad

93 self.name = name (empty)

94 # print(f"DEBUG: actiontriggers.py _Menu name={name}") 

95 self._frame = frame (empty)

96 self.wx_menu = wx.Menu() (empty)

97 self._menu_items = {} (empty)

98 self._name_builder = _NameBuilder() (empty)

99 self._open = False (empty)

100 self._frame.Bind(wx.EVT_MENU_OPEN, self.on_menu_open) (empty)

101 self._frame.Bind(wx.EVT_MENU_CLOSE, self.on_menu_close) (empty)

102 

103 def on_menu_open(self, event): 2 ctx1ad

104 if self.wx_menu == event.GetMenu() and not self._open: 

105 self._open = True 

106 for menu_item in self._menu_items.values(): 

107 menu_item.refresh_availability() 

108 event.Skip() 

109 

110 def on_menu_close(self, event): 2 ctx1ad

111 if self._open: 

112 self._open = False 

113 for menu_item in self._menu_items.values(): 

114 menu_item.set_enabled() 

115 event.Skip() 

116 

117 def add_menu_item(self, action): 2 ctx1ad

118 menu_item = self._construct_menu_item(action) 3 ctx1abc

119 self._menu_items[menu_item.id] = menu_item 3 ctx1abc

120 menu_item.register(action) 3 ctx1abc

121 

122 def _construct_menu_item(self, action): 2 ctx1ad

123 if action.is_separator(): 3 ctx1abc

124 return self._create_separator(action) 3 ctx1abc

125 menu_item = self._get_menu_item(action) 3 ctx1abc

126 if not menu_item: 3 ctx1abc

127 menu_item = self._create_menu_item(action) 3 ctx1abc

128 return menu_item 3 ctx1abc

129 

130 def _create_separator(self, action): 2 ctx1ad

131 menu_item = SeparatorMenuItem(self._frame, self, action) 3 ctx1abc

132 pos = action.get_insertion_index(self.wx_menu) 3 ctx1abc

133 menu_item.set_wx_menu_item(self.wx_menu.InsertSeparator(pos)) 3 ctx1abc

134 return menu_item 3 ctx1abc

135 

136 def _get_menu_item(self, action): 2 ctx1ad

137 for menu_item in self._menu_items.values(): 3 ctx1abc

138 if self._names_equal(menu_item, action): 3 ctx1abc

139 return menu_item (empty)

140 return None 3 ctx1abc

141 

142 def _names_equal(self, menu_item, action): 2 ctx1ad

143 return menu_item.name == self._get_name(action, build_new=False) 3 ctx1abc

144 

145 def _get_name(self, action, build_new): 2 ctx1ad

146 get_name = build_new and self._name_builder.get_name or \ 3 ctx1abc

147 self._name_builder.get_registered_name 

148 if not action.shortcut: # DEBUG not action.shortcut: 148 ↛ 149line 148 didn't jump to line 149 because the condition on line 148 was never true3 ctx1abc

149 return get_name(action.name) 

150 sht = action.get_shortcut() 3 ctx1abc

151 if sht: 3 ctx1abc

152 return '%s (%s)' % (get_name(action.name), sht) 3 ctx1abc

153 return '%s' % get_name(action.name) 2 ctx1ac

154 

155 def _create_menu_item(self, action): 2 ctx1ad

156 name_with_accelerator = self._get_name(action, build_new=True) 3 ctx1abc

157 menu_item = MenuItem(self._frame, self, name_with_accelerator) 3 ctx1abc

158 pos = action.get_insertion_index(self.wx_menu) 3 ctx1abc

159 wx_menu_item = wx.MenuItem(self.wx_menu, menu_item.id, menu_item.name, action.doc) 3 ctx1abc

160 if action.icon: 3 ctx1abc

161 wx_menu_item.SetBitmap(action.icon) (empty)

162 wx_menu_item = self.wx_menu.Insert(pos, wx_menu_item) 3 ctx1abc

163 menu_item.set_wx_menu_item(wx_menu_item) 3 ctx1abc

164 return menu_item 3 ctx1abc

165 

166 def remove_menu_item(self, idd): 2 ctx1ad

167 self.wx_menu.Delete(idd) 

168 del(self._menu_items[idd]) 

169 

170 

171class _NameBuilder(object): 2 ctx1ad

172 

173 def __init__(self): 2 ctx1ad

174 self._names = {} (empty)

175 self._accelerators = [] (empty)

176 

177 def get_name(self, name): 2 ctx1ad

178 registered = self.get_registered_name(name) 12 ctx1abcfjglmkehi

179 if registered: 12 ctx1abcfjglmkehi

180 return registered 1 ctx1k

181 try: 12 ctx1abcfjglmkehi

182 name = self._use_given_accelerator(name) 12 ctx1abcfjglmkehi

183 except ValueError: 9 ctx1abcfjgehi

184 name = self._generate_accelerator(name) 9 ctx1abcfjgehi

185 self._register(name) 12 ctx1abcfjglmkehi

186 # print(f"DEBUG: actiontriggers.py get_name RETURN name={name}") 

187 return name 12 ctx1abcfjglmkehi

188 

189 def get_registered_name(self, name): 2 ctx1ad

190 try: 12 ctx1abcfjglmkehi

191 return self._names[name.replace('&', '').upper()] 12 ctx1abcfjglmkehi

192 except KeyError: 12 ctx1abcfjglmkehi

193 return None 12 ctx1abcfjglmkehi

194 

195 def _register(self, name): 2 ctx1ad

196 self._names[name.replace('&', '').upper()] = name 12 ctx1abcfjglmkehi

197 

198 def _use_given_accelerator(self, name): 2 ctx1ad

199 index = name.find('&') + 1 12 ctx1abcfjglmkehi

200 if 0 < index < len(name) and self._accelerator_is_free(name[index]): 12 ctx1abcfjglmkehi

201 return name 6 ctx1ablmke

202 raise ValueError 9 ctx1abcfjgehi

203 

204 def _generate_accelerator(self, name): 2 ctx1ad

205 name = name.replace('&', '') 9 ctx1abcfjgehi

206 for pos, char in enumerate(name): 9 ctx1abcfjgehi

207 if self._accelerator_is_free(char): 9 ctx1abcfjgehi

208 return '%s&%s' % (name[:pos], name[pos:]) 9 ctx1abcfjgehi

209 return name 4 ctx1abfe

210 

211 def _accelerator_is_free(self, char): 2 ctx1ad

212 char = char.upper() 12 ctx1abcfjglmkehi

213 if char not in self._accelerators and char != u' ': 12 ctx1abcfjglmkehi

214 self._accelerators.append(char) 12 ctx1abcfjglmkehi

215 return True 12 ctx1abcfjglmkehi

216 return False 7 ctx1abfgehi

217 

218 

219class _MenuItem(object): 2 ctx1ad

220 

221 def __init__(self, frame, menu, name): 2 ctx1ad

222 self._frame = frame 3 ctx1abc

223 self._menu = menu 3 ctx1abc

224 self.name = name 3 ctx1abc

225 self._wx_menu_item = None 3 ctx1abc

226 self._action_delegator = ActionDelegator(self._frame) 3 ctx1abc

227 self.id = self._action_delegator.id 3 ctx1abc

228 

229 def set_wx_menu_item(self, wx_menu_item): 2 ctx1ad

230 self._wx_menu_item = wx_menu_item 3 ctx1abc

231 

232 def register(self, action): 2 ctx1ad

233 self._action_delegator.add(action) 3 ctx1abc

234 action.register(self) 3 ctx1abc

235 

236 def unregister(self, action): 2 ctx1ad

237 if self._action_delegator.remove(action): 

238 self._menu.remove_menu_item(self.id) 

239 

240 def refresh_availability(self): 2 ctx1ad

241 self._wx_menu_item.Enable(self._is_enabled()) 

242 

243 def set_enabled(self): 2 ctx1ad

244 self._wx_menu_item.Enable(True) 

245 

246 @staticmethod 2 ctx1ad

247 def _is_enabled(): 2 ctx1ad

248 return NotImplemented 

249 

250 

251class MenuItem(_MenuItem): 2 ctx1ad

252 

253 def _is_enabled(self): 2 ctx1ad

254 return self._action_delegator.is_active() 

255 

256 

257class SeparatorMenuItem(_MenuItem): 2 ctx1ad

258 

259 def set_wx_menu_item(self, wx_menu_item): 2 ctx1ad

260 _MenuItem.set_wx_menu_item(self, wx_menu_item) 3 ctx1abc

261 # Should get ITEM_SEPARATOR 

262 self.id = wx.ID_SEPARATOR 3 ctx1abc

263 

264 @staticmethod 2 ctx1ad

265 def _is_enabled(): 2 ctx1ad

266 return False 

267 

268 def set_enabled(self): 2 ctx1ad

269 """ Just ignore it """ 

270 pass 

271 

272 

273class _RideSearchMenuItem(object): 2 ctx1ad

274 

275 def __init__(self, handler, icon): 2 ctx1ad

276 self._handler = handler (empty)

277 self.icon = icon (empty)

278 

279 def __call__(self, *args, **kwargs): 2 ctx1ad

280 self._handler(*args, **kwargs) 

281 

282 

283class ToolBarButton(object): 2 ctx1ad

284 

285 def __init__(self, frame, toolbar, action): 2 ctx1ad

286 self._toolbar = toolbar (empty)

287 self.icon = action.icon (empty)

288 self._action_delegator = ActionDelegator(frame) (empty)

289 self.id = self._action_delegator.id (empty)

290 

291 def register(self, action): 2 ctx1ad

292 self._action_delegator.add(action) (empty)

293 action.register(self) (empty)

294 action.inform_changes_in_enabled_status(self) (empty)

295 

296 def unregister(self, action): 2 ctx1ad

297 if self._action_delegator.remove(action): 

298 self._toolbar.remove_toolbar_button(self) 

299 

300 def enabled_status_changed(self, action): 2 ctx1ad

301 self._toolbar.enabled_status_changed(self.id, action) (empty)

302 

303 

304class ShortcutRegistry(object): 2 ctx1ad

305 

306 def __init__(self, frame): 2 ctx1ad

307 self._frame = frame (empty)

308 self._actions = {} (empty)

309 

310 def register(self, action): 2 ctx1ad

311 if action.has_shortcut() and action.has_action(): 2 ctx1ab

312 delegator = self._actions.setdefault(action.get_shortcut(), 2 ctx1ab

313 ActionDelegator(self._frame, 

314 action.shortcut)) 

315 delegator.add(action) 2 ctx1ab

316 action.register(self) 2 ctx1ab

317 self._update_accelerator_table() 2 ctx1ab

318 

319 def unregister(self, action): 2 ctx1ad

320 key = action.get_shortcut() 

321 if self._actions[key].remove(action): 

322 del(self._actions[key]) 

323 self._update_accelerator_table() 

324 

325 def _update_accelerator_table(self): 2 ctx1ad

326 accelerators = [] 2 ctx1ab

327 for delegator in self._actions.values(): 2 ctx1ab

328 try: 2 ctx1ab

329 flags, key_code = delegator.shortcut.parse() 2 ctx1ab

330 except TypeError: 2 ctx1ab

331 continue 2 ctx1ab

332 accelerators.append(wx.AcceleratorEntry(flags, key_code, 2 ctx1ab

333 delegator.id)) 

334 self._frame.SetAcceleratorTable(wx.AcceleratorTable(accelerators)) 2 ctx1ab

335 

336 

337class ActionDelegator(object): 2 ctx1ad

338 

339 def __init__(self, frame, shortcut=None): 2 ctx1ad

340 self._frame = frame 3 ctx1abc

341 self.shortcut = shortcut 3 ctx1abc

342 self.id = wx.NewIdRef() 3 ctx1abc

343 self._actions = [] 3 ctx1abc

344 

345 def add(self, action): 2 ctx1ad

346 self._actions.append(action) 3 ctx1abc

347 if len(self._actions) == 1: 3 ctx1abc

348 self._frame.Bind(wx.EVT_MENU, self, id=self.id) 3 ctx1abc

349 

350 def remove(self, action): 2 ctx1ad

351 """Removes action and returns True if delegator is empty.""" 

352 self._actions.remove(action) 

353 if len(self._actions) == 0: 

354 self._frame.Unbind(wx.EVT_MENU, id=self.id) 

355 return True 

356 return False 

357 

358 def is_active(self): 2 ctx1ad

359 for action in self._actions: 

360 if action.is_active(): 

361 return True 

362 return False 

363 

364 def __call__(self, event): 2 ctx1ad

365 for action in self._actions: 

366 action.act(event) 

367 if not (IS_WINDOWS or IS_MAC): 

368 event.Skip()