Mercurial Repositories > eric / file comparison
comparison: eric7/Plugins/VcsPlugins/vcsMercurial/QueuesExtension/ProjectHelper.py
eric7/Plugins/VcsPlugins/vcsMercurial/QueuesExtension/ProjectHelper.py
- branch
- eric7
- changeset 8312
- 800c432b34c8
- parent 8218
- 7c09585bd960
- child 8318
- 962bce857696
equal
deleted
inserted
replaced
| 8311:4e8b98454baa | 8312:800c432b34c8 |
|---|---|
| 1 # -*- coding: utf-8 -*- | |
| 2 | |
| 3 # Copyright (c) 2011 - 2021 Detlev Offenbach <detlev@die-offenbachs.de> | |
| 4 # | |
| 5 | |
| 6 """ | |
| 7 Module implementing the queues extension project helper. | |
| 8 """ | |
| 9 | |
| 10 from PyQt5.QtWidgets import QMenu | |
| 11 | |
| 12 from E5Gui.E5Action import E5Action | |
| 13 from E5Gui import E5MessageBox | |
| 14 | |
| 15 from ..HgExtensionProjectHelper import HgExtensionProjectHelper | |
| 16 | |
| 17 from .queues import Queues | |
| 18 | |
| 19 | |
| 20 class QueuesProjectHelper(HgExtensionProjectHelper): | |
| 21 """ | |
| 22 Class implementing the queues extension project helper. | |
| 23 """ | |
| 24 def __init__(self): | |
| 25 """ | |
| 26 Constructor | |
| 27 """ | |
| 28 super().__init__() | |
| 29 | |
| 30 def initActions(self): | |
| 31 """ | |
| 32 Public method to generate the action objects. | |
| 33 """ | |
| 34 self.hgQueueInitAct = E5Action( | |
| 35 self.tr('Init Queue Repository'), | |
| 36 self.tr('Init Queue Repository'), | |
| 37 0, 0, self, 'mercurial_queues_init') | |
| 38 self.hgQueueInitAct.setStatusTip(self.tr( | |
| 39 'Initialize a new versioned queue repository' | |
| 40 )) | |
| 41 self.hgQueueInitAct.setWhatsThis(self.tr( | |
| 42 """<b>Init Queue Repository</b>""" | |
| 43 """<p>This initializes a new versioned queue repository inside""" | |
| 44 """ the current repository.</p>""" | |
| 45 )) | |
| 46 self.hgQueueInitAct.triggered.connect(self.__hgQueueInit) | |
| 47 self.actions.append(self.hgQueueInitAct) | |
| 48 | |
| 49 self.hgQueueCommitAct = E5Action( | |
| 50 self.tr('Commit changes'), | |
| 51 self.tr('Commit changes...'), | |
| 52 0, 0, self, 'mercurial_queues_commit') | |
| 53 self.hgQueueCommitAct.setStatusTip(self.tr( | |
| 54 'Commit changes in the queue repository' | |
| 55 )) | |
| 56 self.hgQueueCommitAct.setWhatsThis(self.tr( | |
| 57 """<b>Commit changes...</b>""" | |
| 58 """<p>This commits changes in the queue repository.</p>""" | |
| 59 )) | |
| 60 self.hgQueueCommitAct.triggered.connect(self.__hgQueueCommit) | |
| 61 self.actions.append(self.hgQueueCommitAct) | |
| 62 | |
| 63 self.hgQueueNewAct = E5Action( | |
| 64 self.tr('New Patch'), | |
| 65 self.tr('New Patch...'), | |
| 66 0, 0, self, 'mercurial_queues_new') | |
| 67 self.hgQueueNewAct.setStatusTip(self.tr( | |
| 68 'Create a new patch' | |
| 69 )) | |
| 70 self.hgQueueNewAct.setWhatsThis(self.tr( | |
| 71 """<b>New Patch</b>""" | |
| 72 """<p>This creates a new named patch.</p>""" | |
| 73 )) | |
| 74 self.hgQueueNewAct.triggered.connect(self.__hgQueueNewPatch) | |
| 75 self.actions.append(self.hgQueueNewAct) | |
| 76 | |
| 77 self.hgQueueRefreshAct = E5Action( | |
| 78 self.tr('Update Current Patch'), | |
| 79 self.tr('Update Current Patch'), | |
| 80 0, 0, self, 'mercurial_queues_refresh') | |
| 81 self.hgQueueRefreshAct.setStatusTip(self.tr( | |
| 82 'Update the current patch' | |
| 83 )) | |
| 84 self.hgQueueRefreshAct.setWhatsThis(self.tr( | |
| 85 """<b>Update Current Patch</b>""" | |
| 86 """<p>This updates the current patch.</p>""" | |
| 87 )) | |
| 88 self.hgQueueRefreshAct.triggered.connect( | |
| 89 self.__hgQueueRefreshPatch) | |
| 90 self.actions.append(self.hgQueueRefreshAct) | |
| 91 | |
| 92 self.hgQueueRefreshMessageAct = E5Action( | |
| 93 self.tr('Update Current Patch (with Message)'), | |
| 94 self.tr('Update Current Patch (with Message)'), | |
| 95 0, 0, self, 'mercurial_queues_refresh_message') | |
| 96 self.hgQueueRefreshMessageAct.setStatusTip(self.tr( | |
| 97 'Update the current patch and edit commit message' | |
| 98 )) | |
| 99 self.hgQueueRefreshMessageAct.setWhatsThis(self.tr( | |
| 100 """<b>Update Current Patch (with Message)</b>""" | |
| 101 """<p>This updates the current patch after giving the chance""" | |
| 102 """ to change the current commit message.</p>""" | |
| 103 )) | |
| 104 self.hgQueueRefreshMessageAct.triggered.connect( | |
| 105 self.__hgQueueRefreshPatchMessage) | |
| 106 self.actions.append(self.hgQueueRefreshMessageAct) | |
| 107 | |
| 108 self.hgQueueDiffAct = E5Action( | |
| 109 self.tr('Show Current Patch'), | |
| 110 self.tr('Show Current Patch...'), | |
| 111 0, 0, self, 'mercurial_queues_show') | |
| 112 self.hgQueueDiffAct.setStatusTip(self.tr( | |
| 113 'Show the contents the current patch' | |
| 114 )) | |
| 115 self.hgQueueDiffAct.setWhatsThis(self.tr( | |
| 116 """<b>Show Current Patch</b>""" | |
| 117 """<p>This shows the contents of the current patch including""" | |
| 118 """ any changes which have been made in the working directory""" | |
| 119 """ since the last refresh.</p>""" | |
| 120 )) | |
| 121 self.hgQueueDiffAct.triggered.connect(self.__hgQueueShowPatch) | |
| 122 self.actions.append(self.hgQueueDiffAct) | |
| 123 | |
| 124 self.hgQueueHeaderAct = E5Action( | |
| 125 self.tr('Show Current Message'), | |
| 126 self.tr('Show Current Message...'), | |
| 127 0, 0, self, 'mercurial_queues_show_message') | |
| 128 self.hgQueueHeaderAct.setStatusTip(self.tr( | |
| 129 'Show the commit message of the current patch' | |
| 130 )) | |
| 131 self.hgQueueHeaderAct.setWhatsThis(self.tr( | |
| 132 """<b>Show Current Message</b>""" | |
| 133 """<p>This shows the commit message of the current patch.</p>""" | |
| 134 )) | |
| 135 self.hgQueueHeaderAct.triggered.connect(self.__hgQueueShowHeader) | |
| 136 self.actions.append(self.hgQueueHeaderAct) | |
| 137 | |
| 138 self.hgQueueListAct = E5Action( | |
| 139 self.tr('List Patches'), | |
| 140 self.tr('List Patches...'), | |
| 141 0, 0, self, 'mercurial_queues_list') | |
| 142 self.hgQueueListAct.setStatusTip(self.tr( | |
| 143 'List applied and unapplied patches' | |
| 144 )) | |
| 145 self.hgQueueListAct.setWhatsThis(self.tr( | |
| 146 """<b>List Patches</b>""" | |
| 147 """<p>This lists all applied and unapplied patches.</p>""" | |
| 148 )) | |
| 149 self.hgQueueListAct.triggered.connect(self.__hgQueueListPatches) | |
| 150 self.actions.append(self.hgQueueListAct) | |
| 151 | |
| 152 self.hgQueueFinishAct = E5Action( | |
| 153 self.tr('Finish Applied Patches'), | |
| 154 self.tr('Finish Applied Patches'), | |
| 155 0, 0, self, 'mercurial_queues_finish_applied') | |
| 156 self.hgQueueFinishAct.setStatusTip(self.tr( | |
| 157 'Finish applied patches' | |
| 158 )) | |
| 159 self.hgQueueFinishAct.setWhatsThis(self.tr( | |
| 160 """<b>Finish Applied Patches</b>""" | |
| 161 """<p>This finishes the applied patches by moving them out of""" | |
| 162 """ mq control into regular repository history.</p>""" | |
| 163 )) | |
| 164 self.hgQueueFinishAct.triggered.connect( | |
| 165 self.__hgQueueFinishAppliedPatches) | |
| 166 self.actions.append(self.hgQueueFinishAct) | |
| 167 | |
| 168 self.hgQueueRenameAct = E5Action( | |
| 169 self.tr('Rename Patch'), | |
| 170 self.tr('Rename Patch'), | |
| 171 0, 0, self, 'mercurial_queues_rename') | |
| 172 self.hgQueueRenameAct.setStatusTip(self.tr( | |
| 173 'Rename a patch' | |
| 174 )) | |
| 175 self.hgQueueRenameAct.setWhatsThis(self.tr( | |
| 176 """<b>Rename Patch</b>""" | |
| 177 """<p>This renames the current or a named patch.</p>""" | |
| 178 )) | |
| 179 self.hgQueueRenameAct.triggered.connect(self.__hgQueueRenamePatch) | |
| 180 self.actions.append(self.hgQueueRenameAct) | |
| 181 | |
| 182 self.hgQueueDeleteAct = E5Action( | |
| 183 self.tr('Delete Patch'), | |
| 184 self.tr('Delete Patch'), | |
| 185 0, 0, self, 'mercurial_queues_delete') | |
| 186 self.hgQueueDeleteAct.setStatusTip(self.tr( | |
| 187 'Delete unapplied patch' | |
| 188 )) | |
| 189 self.hgQueueDeleteAct.setWhatsThis(self.tr( | |
| 190 """<b>Delete Patch</b>""" | |
| 191 """<p>This deletes an unapplied patch.</p>""" | |
| 192 )) | |
| 193 self.hgQueueDeleteAct.triggered.connect(self.__hgQueueDeletePatch) | |
| 194 self.actions.append(self.hgQueueDeleteAct) | |
| 195 | |
| 196 self.hgQueueFoldAct = E5Action( | |
| 197 self.tr('Fold Patches'), | |
| 198 self.tr('Fold Patches'), | |
| 199 0, 0, self, 'mercurial_queues_fold') | |
| 200 self.hgQueueFoldAct.setStatusTip(self.tr( | |
| 201 'Fold unapplied patches into the current patch' | |
| 202 )) | |
| 203 self.hgQueueFoldAct.setWhatsThis(self.tr( | |
| 204 """<b>Fold Patches</b>""" | |
| 205 """<p>This folds unapplied patches into the current patch.</p>""" | |
| 206 )) | |
| 207 self.hgQueueFoldAct.triggered.connect( | |
| 208 self.__hgQueueFoldUnappliedPatches) | |
| 209 self.actions.append(self.hgQueueFoldAct) | |
| 210 | |
| 211 self.hgQueueStatusAct = E5Action( | |
| 212 self.tr('Show Status'), | |
| 213 self.tr('Show &Status...'), | |
| 214 0, 0, self, 'mercurial_queues_status') | |
| 215 self.hgQueueStatusAct.setStatusTip(self.tr( | |
| 216 'Show the status of the queue repository' | |
| 217 )) | |
| 218 self.hgQueueStatusAct.setWhatsThis(self.tr( | |
| 219 """<b>Show Status</b>""" | |
| 220 """<p>This shows the status of the queue repository.</p>""" | |
| 221 )) | |
| 222 self.hgQueueStatusAct.triggered.connect(self.__hgQueueStatus) | |
| 223 self.actions.append(self.hgQueueStatusAct) | |
| 224 | |
| 225 self.hgQueueSummaryAct = E5Action( | |
| 226 self.tr('Show Summary'), | |
| 227 self.tr('Show summary...'), | |
| 228 0, 0, self, 'mercurial_queues_summary') | |
| 229 self.hgQueueSummaryAct.setStatusTip(self.tr( | |
| 230 'Show summary information of the queue repository' | |
| 231 )) | |
| 232 self.hgQueueSummaryAct.setWhatsThis(self.tr( | |
| 233 """<b>Show summary</b>""" | |
| 234 """<p>This shows some summary information of the queue""" | |
| 235 """ repository.</p>""" | |
| 236 )) | |
| 237 self.hgQueueSummaryAct.triggered.connect(self.__hgQueueSummary) | |
| 238 self.actions.append(self.hgQueueSummaryAct) | |
| 239 | |
| 240 self.__initPushPopActions() | |
| 241 self.__initPushPopForceActions() | |
| 242 self.__initGuardsActions() | |
| 243 self.__initQueuesMgmtActions() | |
| 244 | |
| 245 def __initPushPopActions(self): | |
| 246 """ | |
| 247 Private method to generate the push and pop action objects. | |
| 248 """ | |
| 249 self.hgQueuePushAct = E5Action( | |
| 250 self.tr('Push Next Patch'), | |
| 251 self.tr('Push Next Patch'), | |
| 252 0, 0, self, 'mercurial_queues_push_next') | |
| 253 self.hgQueuePushAct.setStatusTip(self.tr( | |
| 254 'Push the next patch onto the stack' | |
| 255 )) | |
| 256 self.hgQueuePushAct.setWhatsThis(self.tr( | |
| 257 """<b>Push Next Patch</b>""" | |
| 258 """<p>This pushes the next patch onto the stack of applied""" | |
| 259 """ patches.</p>""" | |
| 260 )) | |
| 261 self.hgQueuePushAct.triggered.connect(self.__hgQueuePushPatch) | |
| 262 self.actions.append(self.hgQueuePushAct) | |
| 263 | |
| 264 self.hgQueuePushAllAct = E5Action( | |
| 265 self.tr('Push All Patches'), | |
| 266 self.tr('Push All Patches'), | |
| 267 0, 0, self, 'mercurial_queues_push_all') | |
| 268 self.hgQueuePushAllAct.setStatusTip(self.tr( | |
| 269 'Push all patches onto the stack' | |
| 270 )) | |
| 271 self.hgQueuePushAllAct.setWhatsThis(self.tr( | |
| 272 """<b>Push All Patches</b>""" | |
| 273 """<p>This pushes all patches onto the stack of applied""" | |
| 274 """ patches.</p>""" | |
| 275 )) | |
| 276 self.hgQueuePushAllAct.triggered.connect( | |
| 277 self.__hgQueuePushAllPatches) | |
| 278 self.actions.append(self.hgQueuePushAllAct) | |
| 279 | |
| 280 self.hgQueuePushUntilAct = E5Action( | |
| 281 self.tr('Push Patches'), | |
| 282 self.tr('Push Patches'), | |
| 283 0, 0, self, 'mercurial_queues_push_until') | |
| 284 self.hgQueuePushUntilAct.setStatusTip(self.tr( | |
| 285 'Push patches onto the stack' | |
| 286 )) | |
| 287 self.hgQueuePushUntilAct.setWhatsThis(self.tr( | |
| 288 """<b>Push Patches</b>""" | |
| 289 """<p>This pushes patches onto the stack of applied patches""" | |
| 290 """ until a named patch is at the top of the stack.</p>""" | |
| 291 )) | |
| 292 self.hgQueuePushUntilAct.triggered.connect( | |
| 293 self.__hgQueuePushPatches) | |
| 294 self.actions.append(self.hgQueuePushUntilAct) | |
| 295 | |
| 296 self.hgQueuePopAct = E5Action( | |
| 297 self.tr('Pop Current Patch'), | |
| 298 self.tr('Pop Current Patch'), | |
| 299 0, 0, self, 'mercurial_queues_pop_current') | |
| 300 self.hgQueuePopAct.setStatusTip(self.tr( | |
| 301 'Pop the current patch off the stack' | |
| 302 )) | |
| 303 self.hgQueuePopAct.setWhatsThis(self.tr( | |
| 304 """<b>Pop Current Patch</b>""" | |
| 305 """<p>This pops the current patch off the stack of applied""" | |
| 306 """ patches.</p>""" | |
| 307 )) | |
| 308 self.hgQueuePopAct.triggered.connect(self.__hgQueuePopPatch) | |
| 309 self.actions.append(self.hgQueuePopAct) | |
| 310 | |
| 311 self.hgQueuePopAllAct = E5Action( | |
| 312 self.tr('Pop All Patches'), | |
| 313 self.tr('Pop All Patches'), | |
| 314 0, 0, self, 'mercurial_queues_pop_all') | |
| 315 self.hgQueuePopAllAct.setStatusTip(self.tr( | |
| 316 'Pop all patches off the stack' | |
| 317 )) | |
| 318 self.hgQueuePopAllAct.setWhatsThis(self.tr( | |
| 319 """<b>Pop All Patches</b>""" | |
| 320 """<p>This pops all patches off the stack of applied""" | |
| 321 """ patches.</p>""" | |
| 322 )) | |
| 323 self.hgQueuePopAllAct.triggered.connect( | |
| 324 self.__hgQueuePopAllPatches) | |
| 325 self.actions.append(self.hgQueuePopAllAct) | |
| 326 | |
| 327 self.hgQueuePopUntilAct = E5Action( | |
| 328 self.tr('Pop Patches'), | |
| 329 self.tr('Pop Patches'), | |
| 330 0, 0, self, 'mercurial_queues_pop_until') | |
| 331 self.hgQueuePopUntilAct.setStatusTip(self.tr( | |
| 332 'Pop patches off the stack' | |
| 333 )) | |
| 334 self.hgQueuePopUntilAct.setWhatsThis(self.tr( | |
| 335 """<b>Pop Patches</b>""" | |
| 336 """<p>This pops patches off the stack of applied patches""" | |
| 337 """ until a named patch is at the top of the stack.</p>""" | |
| 338 )) | |
| 339 self.hgQueuePopUntilAct.triggered.connect(self.__hgQueuePopPatches) | |
| 340 self.actions.append(self.hgQueuePopUntilAct) | |
| 341 | |
| 342 self.hgQueueGotoAct = E5Action( | |
| 343 self.tr('Go to Patch'), | |
| 344 self.tr('Go to Patch'), | |
| 345 0, 0, self, 'mercurial_queues_goto') | |
| 346 self.hgQueueGotoAct.setStatusTip(self.tr( | |
| 347 'Push or pop patches until named patch is at top of stack' | |
| 348 )) | |
| 349 self.hgQueueGotoAct.setWhatsThis(self.tr( | |
| 350 """<b>Go to Patch</b>""" | |
| 351 """<p>This pushes or pops patches until a named patch is at the""" | |
| 352 """ top of the stack.</p>""" | |
| 353 )) | |
| 354 self.hgQueueGotoAct.triggered.connect(self.__hgQueueGotoPatch) | |
| 355 self.actions.append(self.hgQueueGotoAct) | |
| 356 | |
| 357 def __initPushPopForceActions(self): | |
| 358 """ | |
| 359 Private method to generate the push and pop (force) action objects. | |
| 360 """ | |
| 361 self.hgQueuePushForceAct = E5Action( | |
| 362 self.tr('Push Next Patch'), | |
| 363 self.tr('Push Next Patch'), | |
| 364 0, 0, self, 'mercurial_queues_push_next_force') | |
| 365 self.hgQueuePushForceAct.setStatusTip(self.tr( | |
| 366 'Push the next patch onto the stack on top of local changes' | |
| 367 )) | |
| 368 self.hgQueuePushForceAct.setWhatsThis(self.tr( | |
| 369 """<b>Push Next Patch</b>""" | |
| 370 """<p>This pushes the next patch onto the stack of applied""" | |
| 371 """ patches on top of local changes.</p>""" | |
| 372 )) | |
| 373 self.hgQueuePushForceAct.triggered.connect( | |
| 374 self.__hgQueuePushPatchForced) | |
| 375 self.actions.append(self.hgQueuePushForceAct) | |
| 376 | |
| 377 self.hgQueuePushAllForceAct = E5Action( | |
| 378 self.tr('Push All Patches'), | |
| 379 self.tr('Push All Patches'), | |
| 380 0, 0, self, 'mercurial_queues_push_all_force') | |
| 381 self.hgQueuePushAllForceAct.setStatusTip(self.tr( | |
| 382 'Push all patches onto the stack on top of local changes' | |
| 383 )) | |
| 384 self.hgQueuePushAllForceAct.setWhatsThis(self.tr( | |
| 385 """<b>Push All Patches</b>""" | |
| 386 """<p>This pushes all patches onto the stack of applied patches""" | |
| 387 """ on top of local changes.</p>""" | |
| 388 )) | |
| 389 self.hgQueuePushAllForceAct.triggered.connect( | |
| 390 self.__hgQueuePushAllPatchesForced) | |
| 391 self.actions.append(self.hgQueuePushAllForceAct) | |
| 392 | |
| 393 self.hgQueuePushUntilForceAct = E5Action( | |
| 394 self.tr('Push Patches'), | |
| 395 self.tr('Push Patches'), | |
| 396 0, 0, self, 'mercurial_queues_push_until_force') | |
| 397 self.hgQueuePushUntilForceAct.setStatusTip(self.tr( | |
| 398 'Push patches onto the stack on top of local changes' | |
| 399 )) | |
| 400 self.hgQueuePushUntilForceAct.setWhatsThis(self.tr( | |
| 401 """<b>Push Patches</b>""" | |
| 402 """<p>This pushes patches onto the stack of applied patches""" | |
| 403 """ until a named patch is at the top of the stack on top of""" | |
| 404 """ local changes.</p>""" | |
| 405 )) | |
| 406 self.hgQueuePushUntilForceAct.triggered.connect( | |
| 407 self.__hgQueuePushPatchesForced) | |
| 408 self.actions.append(self.hgQueuePushUntilForceAct) | |
| 409 | |
| 410 self.hgQueuePopForceAct = E5Action( | |
| 411 self.tr('Pop Current Patch'), | |
| 412 self.tr('Pop Current Patch'), | |
| 413 0, 0, self, 'mercurial_queues_pop_current_force') | |
| 414 self.hgQueuePopForceAct.setStatusTip(self.tr( | |
| 415 'Pop the current patch off the stack forgetting local changes' | |
| 416 )) | |
| 417 self.hgQueuePopForceAct.setWhatsThis(self.tr( | |
| 418 """<b>Pop Current Patch</b>""" | |
| 419 """<p>This pops the current patch off the stack of applied""" | |
| 420 """ patches""" | |
| 421 """ forgetting local changes.</p>""" | |
| 422 )) | |
| 423 self.hgQueuePopForceAct.triggered.connect( | |
| 424 self.__hgQueuePopPatchForced) | |
| 425 self.actions.append(self.hgQueuePopForceAct) | |
| 426 | |
| 427 self.hgQueuePopAllForceAct = E5Action( | |
| 428 self.tr('Pop All Patches'), | |
| 429 self.tr('Pop All Patches'), | |
| 430 0, 0, self, 'mercurial_queues_pop_all_force') | |
| 431 self.hgQueuePopAllForceAct.setStatusTip(self.tr( | |
| 432 'Pop all patches off the stack forgetting local changes' | |
| 433 )) | |
| 434 self.hgQueuePopAllForceAct.setWhatsThis(self.tr( | |
| 435 """<b>Pop All Patches</b>""" | |
| 436 """<p>This pops all patches off the stack of applied patches""" | |
| 437 """ forgetting local changes.</p>""" | |
| 438 )) | |
| 439 self.hgQueuePopAllForceAct.triggered.connect( | |
| 440 self.__hgQueuePopAllPatchesForced) | |
| 441 self.actions.append(self.hgQueuePopAllForceAct) | |
| 442 | |
| 443 self.hgQueuePopUntilForceAct = E5Action( | |
| 444 self.tr('Pop Patches'), | |
| 445 self.tr('Pop Patches'), | |
| 446 0, 0, self, 'mercurial_queues_pop_until_force') | |
| 447 self.hgQueuePopUntilForceAct.setStatusTip(self.tr( | |
| 448 'Pop patches off the stack forgetting local changes' | |
| 449 )) | |
| 450 self.hgQueuePopUntilForceAct.setWhatsThis(self.tr( | |
| 451 """<b>Pop Patches</b>""" | |
| 452 """<p>This pops patches off the stack of applied patches until""" | |
| 453 """ a named patch is at the top of the stack forgetting local""" | |
| 454 """ changes.</p>""" | |
| 455 )) | |
| 456 self.hgQueuePopUntilForceAct.triggered.connect( | |
| 457 self.__hgQueuePopPatchesForced) | |
| 458 self.actions.append(self.hgQueuePopUntilForceAct) | |
| 459 | |
| 460 self.hgQueueGotoForceAct = E5Action( | |
| 461 self.tr('Go to Patch'), | |
| 462 self.tr('Go to Patch'), | |
| 463 0, 0, self, 'mercurial_queues_goto_force') | |
| 464 self.hgQueueGotoForceAct.setStatusTip(self.tr( | |
| 465 'Push or pop patches until named patch is at top of stack' | |
| 466 ' overwriting any local changes' | |
| 467 )) | |
| 468 self.hgQueueGotoForceAct.setWhatsThis(self.tr( | |
| 469 """<b>Go to Patch</b>""" | |
| 470 """<p>This pushes or pops patches until a named patch is at the""" | |
| 471 """ top of the stack overwriting any local changes.</p>""" | |
| 472 )) | |
| 473 self.hgQueueGotoForceAct.triggered.connect( | |
| 474 self.__hgQueueGotoPatchForced) | |
| 475 self.actions.append(self.hgQueueGotoForceAct) | |
| 476 | |
| 477 def __initGuardsActions(self): | |
| 478 """ | |
| 479 Private method to generate the guards action objects. | |
| 480 """ | |
| 481 self.hgQueueDefineGuardsAct = E5Action( | |
| 482 self.tr('Define Guards'), | |
| 483 self.tr('Define Guards...'), | |
| 484 0, 0, self, 'mercurial_queues_guards_define') | |
| 485 self.hgQueueDefineGuardsAct.setStatusTip(self.tr( | |
| 486 'Define guards for the current or a named patch' | |
| 487 )) | |
| 488 self.hgQueueDefineGuardsAct.setWhatsThis(self.tr( | |
| 489 """<b>Define Guards</b>""" | |
| 490 """<p>This opens a dialog to define guards for the current""" | |
| 491 """ or a named patch.</p>""" | |
| 492 )) | |
| 493 self.hgQueueDefineGuardsAct.triggered.connect( | |
| 494 self.__hgQueueGuardsDefine) | |
| 495 self.actions.append(self.hgQueueDefineGuardsAct) | |
| 496 | |
| 497 self.hgQueueDropAllGuardsAct = E5Action( | |
| 498 self.tr('Drop All Guards'), | |
| 499 self.tr('Drop All Guards...'), | |
| 500 0, 0, self, 'mercurial_queues_guards_drop_all') | |
| 501 self.hgQueueDropAllGuardsAct.setStatusTip(self.tr( | |
| 502 'Drop all guards of the current or a named patch' | |
| 503 )) | |
| 504 self.hgQueueDropAllGuardsAct.setWhatsThis(self.tr( | |
| 505 """<b>Drop All Guards</b>""" | |
| 506 """<p>This drops all guards of the current or a named patch.</p>""" | |
| 507 )) | |
| 508 self.hgQueueDropAllGuardsAct.triggered.connect( | |
| 509 self.__hgQueueGuardsDropAll) | |
| 510 self.actions.append(self.hgQueueDropAllGuardsAct) | |
| 511 | |
| 512 self.hgQueueListGuardsAct = E5Action( | |
| 513 self.tr('List Guards'), | |
| 514 self.tr('List Guards...'), | |
| 515 0, 0, self, 'mercurial_queues_guards_list') | |
| 516 self.hgQueueListGuardsAct.setStatusTip(self.tr( | |
| 517 'List guards of the current or a named patch' | |
| 518 )) | |
| 519 self.hgQueueListGuardsAct.setWhatsThis(self.tr( | |
| 520 """<b>List Guards</b>""" | |
| 521 """<p>This lists the guards of the current or a named patch.</p>""" | |
| 522 )) | |
| 523 self.hgQueueListGuardsAct.triggered.connect( | |
| 524 self.__hgQueueGuardsList) | |
| 525 self.actions.append(self.hgQueueListGuardsAct) | |
| 526 | |
| 527 self.hgQueueListAllGuardsAct = E5Action( | |
| 528 self.tr('List All Guards'), | |
| 529 self.tr('List All Guards...'), | |
| 530 0, 0, self, 'mercurial_queues_guards_list_all') | |
| 531 self.hgQueueListAllGuardsAct.setStatusTip(self.tr( | |
| 532 'List all guards of all patches' | |
| 533 )) | |
| 534 self.hgQueueListAllGuardsAct.setWhatsThis(self.tr( | |
| 535 """<b>List All Guards</b>""" | |
| 536 """<p>This lists all guards of all patches.</p>""" | |
| 537 )) | |
| 538 self.hgQueueListAllGuardsAct.triggered.connect( | |
| 539 self.__hgQueueGuardsListAll) | |
| 540 self.actions.append(self.hgQueueListAllGuardsAct) | |
| 541 | |
| 542 self.hgQueueActivateGuardsAct = E5Action( | |
| 543 self.tr('Set Active Guards'), | |
| 544 self.tr('Set Active Guards...'), | |
| 545 0, 0, self, 'mercurial_queues_guards_set_active') | |
| 546 self.hgQueueActivateGuardsAct.setStatusTip(self.tr( | |
| 547 'Set the list of active guards' | |
| 548 )) | |
| 549 self.hgQueueActivateGuardsAct.setWhatsThis(self.tr( | |
| 550 """<b>Set Active Guards</b>""" | |
| 551 """<p>This opens a dialog to set the active guards.</p>""" | |
| 552 )) | |
| 553 self.hgQueueActivateGuardsAct.triggered.connect( | |
| 554 self.__hgQueueGuardsSetActive) | |
| 555 self.actions.append(self.hgQueueActivateGuardsAct) | |
| 556 | |
| 557 self.hgQueueDeactivateGuardsAct = E5Action( | |
| 558 self.tr('Deactivate Guards'), | |
| 559 self.tr('Deactivate Guards...'), | |
| 560 0, 0, self, 'mercurial_queues_guards_deactivate') | |
| 561 self.hgQueueDeactivateGuardsAct.setStatusTip(self.tr( | |
| 562 'Deactivate all active guards' | |
| 563 )) | |
| 564 self.hgQueueDeactivateGuardsAct.setWhatsThis(self.tr( | |
| 565 """<b>Deactivate Guards</b>""" | |
| 566 """<p>This deactivates all active guards.</p>""" | |
| 567 )) | |
| 568 self.hgQueueDeactivateGuardsAct.triggered.connect( | |
| 569 self.__hgQueueGuardsDeactivate) | |
| 570 self.actions.append(self.hgQueueDeactivateGuardsAct) | |
| 571 | |
| 572 self.hgQueueIdentifyActiveGuardsAct = E5Action( | |
| 573 self.tr('Identify Active Guards'), | |
| 574 self.tr('Identify Active Guards...'), | |
| 575 0, 0, self, 'mercurial_queues_guards_identify_active') | |
| 576 self.hgQueueIdentifyActiveGuardsAct.setStatusTip(self.tr( | |
| 577 'Show a list of active guards' | |
| 578 )) | |
| 579 self.hgQueueIdentifyActiveGuardsAct.setWhatsThis(self.tr( | |
| 580 """<b>Identify Active Guards</b>""" | |
| 581 """<p>This opens a dialog showing a list of active guards.</p>""" | |
| 582 )) | |
| 583 self.hgQueueIdentifyActiveGuardsAct.triggered.connect( | |
| 584 self.__hgQueueGuardsIdentifyActive) | |
| 585 self.actions.append(self.hgQueueIdentifyActiveGuardsAct) | |
| 586 | |
| 587 def __initQueuesMgmtActions(self): | |
| 588 """ | |
| 589 Private method to generate the queues management action objects. | |
| 590 """ | |
| 591 self.hgQueueCreateQueueAct = E5Action( | |
| 592 self.tr('Create Queue'), | |
| 593 self.tr('Create Queue'), | |
| 594 0, 0, self, 'mercurial_queues_create_queue') | |
| 595 self.hgQueueCreateQueueAct.setStatusTip(self.tr( | |
| 596 'Create a new patch queue' | |
| 597 )) | |
| 598 self.hgQueueCreateQueueAct.setWhatsThis(self.tr( | |
| 599 """<b>Create Queue</b>""" | |
| 600 """<p>This creates a new patch queue.</p>""" | |
| 601 )) | |
| 602 self.hgQueueCreateQueueAct.triggered.connect( | |
| 603 self.__hgQueueCreateQueue) | |
| 604 self.actions.append(self.hgQueueCreateQueueAct) | |
| 605 | |
| 606 self.hgQueueRenameQueueAct = E5Action( | |
| 607 self.tr('Rename Queue'), | |
| 608 self.tr('Rename Queue'), | |
| 609 0, 0, self, 'mercurial_queues_rename_queue') | |
| 610 self.hgQueueRenameQueueAct.setStatusTip(self.tr( | |
| 611 'Rename the active patch queue' | |
| 612 )) | |
| 613 self.hgQueueRenameQueueAct.setWhatsThis(self.tr( | |
| 614 """<b>Rename Queue</b>""" | |
| 615 """<p>This renames the active patch queue.</p>""" | |
| 616 )) | |
| 617 self.hgQueueRenameQueueAct.triggered.connect( | |
| 618 self.__hgQueueRenameQueue) | |
| 619 self.actions.append(self.hgQueueRenameQueueAct) | |
| 620 | |
| 621 self.hgQueueDeleteQueueAct = E5Action( | |
| 622 self.tr('Delete Queue'), | |
| 623 self.tr('Delete Queue'), | |
| 624 0, 0, self, 'mercurial_queues_delete_queue') | |
| 625 self.hgQueueDeleteQueueAct.setStatusTip(self.tr( | |
| 626 'Delete the reference to a patch queue' | |
| 627 )) | |
| 628 self.hgQueueDeleteQueueAct.setWhatsThis(self.tr( | |
| 629 """<b>Delete Queue</b>""" | |
| 630 """<p>This deletes the reference to a patch queue.</p>""" | |
| 631 )) | |
| 632 self.hgQueueDeleteQueueAct.triggered.connect( | |
| 633 self.__hgQueueDeleteQueue) | |
| 634 self.actions.append(self.hgQueueDeleteQueueAct) | |
| 635 | |
| 636 self.hgQueuePurgeQueueAct = E5Action( | |
| 637 self.tr('Purge Queue'), | |
| 638 self.tr('Purge Queue'), | |
| 639 0, 0, self, 'mercurial_queues_purge_queue') | |
| 640 self.hgQueuePurgeQueueAct.setStatusTip(self.tr( | |
| 641 'Delete the reference to a patch queue and remove the patch' | |
| 642 ' directory' | |
| 643 )) | |
| 644 self.hgQueuePurgeQueueAct.setWhatsThis(self.tr( | |
| 645 """<b>Purge Queue</b>""" | |
| 646 """<p>This deletes the reference to a patch queue and removes""" | |
| 647 """ the patch directory.</p>""" | |
| 648 )) | |
| 649 self.hgQueuePurgeQueueAct.triggered.connect( | |
| 650 self.__hgQueuePurgeQueue) | |
| 651 self.actions.append(self.hgQueuePurgeQueueAct) | |
| 652 | |
| 653 self.hgQueueActivateQueueAct = E5Action( | |
| 654 self.tr('Activate Queue'), | |
| 655 self.tr('Activate Queue'), | |
| 656 0, 0, self, 'mercurial_queues_activate_queue') | |
| 657 self.hgQueueActivateQueueAct.setStatusTip(self.tr( | |
| 658 'Set the active queue' | |
| 659 )) | |
| 660 self.hgQueueActivateQueueAct.setWhatsThis(self.tr( | |
| 661 """<b>Activate Queue</b>""" | |
| 662 """<p>This sets the active queue.</p>""" | |
| 663 )) | |
| 664 self.hgQueueActivateQueueAct.triggered.connect( | |
| 665 self.__hgQueueActivateQueue) | |
| 666 self.actions.append(self.hgQueueActivateQueueAct) | |
| 667 | |
| 668 self.hgQueueListQueuesAct = E5Action( | |
| 669 self.tr('List Queues'), | |
| 670 self.tr('List Queues...'), | |
| 671 0, 0, self, 'mercurial_queues_list_queues') | |
| 672 self.hgQueueListQueuesAct.setStatusTip(self.tr( | |
| 673 'List the available queues' | |
| 674 )) | |
| 675 self.hgQueueListQueuesAct.setWhatsThis(self.tr( | |
| 676 """<b>List Queues</b>""" | |
| 677 """<p>This opens a dialog showing all available queues.</p>""" | |
| 678 )) | |
| 679 self.hgQueueListQueuesAct.triggered.connect( | |
| 680 self.__hgQueueListQueues) | |
| 681 self.actions.append(self.hgQueueListQueuesAct) | |
| 682 | |
| 683 def initMenu(self, mainMenu): | |
| 684 """ | |
| 685 Public method to generate the extension menu. | |
| 686 | |
| 687 @param mainMenu reference to the main menu (QMenu) | |
| 688 @return populated menu (QMenu) | |
| 689 """ | |
| 690 menu = QMenu(self.menuTitle(), mainMenu) | |
| 691 menu.setTearOffEnabled(True) | |
| 692 | |
| 693 pushPopMenu = QMenu(self.tr("Push/Pop"), menu) | |
| 694 pushPopMenu.setTearOffEnabled(True) | |
| 695 pushPopMenu.addAction(self.hgQueuePushAct) | |
| 696 pushPopMenu.addAction(self.hgQueuePushUntilAct) | |
| 697 pushPopMenu.addAction(self.hgQueuePushAllAct) | |
| 698 pushPopMenu.addSeparator() | |
| 699 pushPopMenu.addAction(self.hgQueuePopAct) | |
| 700 pushPopMenu.addAction(self.hgQueuePopUntilAct) | |
| 701 pushPopMenu.addAction(self.hgQueuePopAllAct) | |
| 702 pushPopMenu.addSeparator() | |
| 703 pushPopMenu.addAction(self.hgQueueGotoAct) | |
| 704 | |
| 705 pushPopForceMenu = QMenu(self.tr("Push/Pop (force)"), menu) | |
| 706 pushPopForceMenu.setTearOffEnabled(True) | |
| 707 pushPopForceMenu.addAction(self.hgQueuePushForceAct) | |
| 708 pushPopForceMenu.addAction(self.hgQueuePushUntilForceAct) | |
| 709 pushPopForceMenu.addAction(self.hgQueuePushAllForceAct) | |
| 710 pushPopForceMenu.addSeparator() | |
| 711 pushPopForceMenu.addAction(self.hgQueuePopForceAct) | |
| 712 pushPopForceMenu.addAction(self.hgQueuePopUntilForceAct) | |
| 713 pushPopForceMenu.addAction(self.hgQueuePopAllForceAct) | |
| 714 pushPopForceMenu.addSeparator() | |
| 715 pushPopForceMenu.addAction(self.hgQueueGotoForceAct) | |
| 716 | |
| 717 guardsMenu = QMenu(self.tr("Guards"), menu) | |
| 718 guardsMenu.setTearOffEnabled(True) | |
| 719 guardsMenu.addAction(self.hgQueueDefineGuardsAct) | |
| 720 guardsMenu.addAction(self.hgQueueDropAllGuardsAct) | |
| 721 guardsMenu.addSeparator() | |
| 722 guardsMenu.addAction(self.hgQueueListGuardsAct) | |
| 723 guardsMenu.addAction(self.hgQueueListAllGuardsAct) | |
| 724 guardsMenu.addSeparator() | |
| 725 guardsMenu.addAction(self.hgQueueActivateGuardsAct) | |
| 726 guardsMenu.addAction(self.hgQueueDeactivateGuardsAct) | |
| 727 guardsMenu.addSeparator() | |
| 728 guardsMenu.addAction(self.hgQueueIdentifyActiveGuardsAct) | |
| 729 | |
| 730 queuesMenu = QMenu(self.tr("Queue Management"), menu) | |
| 731 queuesMenu.setTearOffEnabled(True) | |
| 732 queuesMenu.addAction(self.hgQueueCreateQueueAct) | |
| 733 queuesMenu.addAction(self.hgQueueRenameQueueAct) | |
| 734 queuesMenu.addAction(self.hgQueueDeleteQueueAct) | |
| 735 queuesMenu.addAction(self.hgQueuePurgeQueueAct) | |
| 736 queuesMenu.addSeparator() | |
| 737 queuesMenu.addAction(self.hgQueueActivateQueueAct) | |
| 738 queuesMenu.addSeparator() | |
| 739 queuesMenu.addAction(self.hgQueueListQueuesAct) | |
| 740 | |
| 741 menu.addAction(self.hgQueueInitAct) | |
| 742 menu.addAction(self.hgQueueCommitAct) | |
| 743 menu.addSeparator() | |
| 744 menu.addAction(self.hgQueueNewAct) | |
| 745 menu.addAction(self.hgQueueRefreshAct) | |
| 746 menu.addAction(self.hgQueueRefreshMessageAct) | |
| 747 menu.addAction(self.hgQueueFinishAct) | |
| 748 menu.addSeparator() | |
| 749 menu.addAction(self.hgQueueStatusAct) | |
| 750 menu.addAction(self.hgQueueSummaryAct) | |
| 751 menu.addSeparator() | |
| 752 menu.addAction(self.hgQueueDiffAct) | |
| 753 menu.addAction(self.hgQueueHeaderAct) | |
| 754 menu.addSeparator() | |
| 755 menu.addAction(self.hgQueueListAct) | |
| 756 menu.addSeparator() | |
| 757 menu.addMenu(pushPopMenu) | |
| 758 menu.addMenu(pushPopForceMenu) | |
| 759 menu.addSeparator() | |
| 760 menu.addAction(self.hgQueueRenameAct) | |
| 761 menu.addAction(self.hgQueueDeleteAct) | |
| 762 menu.addSeparator() | |
| 763 menu.addAction(self.hgQueueFoldAct) | |
| 764 menu.addSeparator() | |
| 765 menu.addMenu(guardsMenu) | |
| 766 menu.addSeparator() | |
| 767 menu.addMenu(queuesMenu) | |
| 768 | |
| 769 return menu | |
| 770 | |
| 771 def menuTitle(self): | |
| 772 """ | |
| 773 Public method to get the menu title. | |
| 774 | |
| 775 @return title of the menu (string) | |
| 776 """ | |
| 777 return self.tr("Queues") | |
| 778 | |
| 779 def __hgQueueNewPatch(self): | |
| 780 """ | |
| 781 Private slot used to create a new named patch. | |
| 782 """ | |
| 783 self.vcs.getExtensionObject("mq").hgQueueNewPatch() | |
| 784 | |
| 785 def __hgQueueRefreshPatch(self): | |
| 786 """ | |
| 787 Private slot used to refresh the current patch. | |
| 788 """ | |
| 789 self.vcs.getExtensionObject("mq").hgQueueRefreshPatch() | |
| 790 | |
| 791 def __hgQueueRefreshPatchMessage(self): | |
| 792 """ | |
| 793 Private slot used to refresh the current patch and its commit message. | |
| 794 """ | |
| 795 self.vcs.getExtensionObject("mq").hgQueueRefreshPatch(editMessage=True) | |
| 796 | |
| 797 def __hgQueueShowPatch(self): | |
| 798 """ | |
| 799 Private slot used to show the contents of the current patch. | |
| 800 """ | |
| 801 self.vcs.getExtensionObject("mq").hgQueueShowPatch( | |
| 802 self.project.getProjectPath()) | |
| 803 | |
| 804 def __hgQueueShowHeader(self): | |
| 805 """ | |
| 806 Private slot used to show the commit message of the current patch. | |
| 807 """ | |
| 808 self.vcs.getExtensionObject("mq").hgQueueShowHeader() | |
| 809 | |
| 810 def __hgQueuePushPopPatches(self, operation, doAll=False, | |
| 811 named=False, force=False): | |
| 812 """ | |
| 813 Private method to push patches onto the stack or pop patches off the | |
| 814 stack. | |
| 815 | |
| 816 @param operation operation type to be performed (Queues.POP, | |
| 817 Queues.PUSH, Queues.GOTO) | |
| 818 @param doAll flag indicating to push/pop all (boolean) | |
| 819 @param named flag indicating to push/pop until a named patch | |
| 820 is at the top of the stack (boolean) | |
| 821 @param force flag indicating a forceful pop (boolean) | |
| 822 """ | |
| 823 shouldReopen = self.vcs.getExtensionObject("mq").hgQueuePushPopPatches( | |
| 824 operation=operation, doAll=doAll, named=named, force=force) | |
| 825 if shouldReopen: | |
| 826 res = E5MessageBox.yesNo( | |
| 827 None, | |
| 828 self.tr("Changing Applied Patches"), | |
| 829 self.tr("""The project should be reread. Do this now?"""), | |
| 830 yesDefault=True) | |
| 831 if res: | |
| 832 self.project.reopenProject() | |
| 833 | |
| 834 def __hgQueuePushPatch(self): | |
| 835 """ | |
| 836 Private slot used to push the next patch onto the stack. | |
| 837 """ | |
| 838 self.__hgQueuePushPopPatches( | |
| 839 operation=Queues.PUSH, doAll=False, named=False) | |
| 840 | |
| 841 def __hgQueuePushPatchForced(self): | |
| 842 """ | |
| 843 Private slot used to push the next patch onto the stack on top | |
| 844 of local changes. | |
| 845 """ | |
| 846 self.__hgQueuePushPopPatches( | |
| 847 operation=Queues.PUSH, doAll=False, named=False, force=True) | |
| 848 | |
| 849 def __hgQueuePushAllPatches(self): | |
| 850 """ | |
| 851 Private slot used to push all patches onto the stack. | |
| 852 """ | |
| 853 self.__hgQueuePushPopPatches( | |
| 854 operation=Queues.PUSH, doAll=True, named=False) | |
| 855 | |
| 856 def __hgQueuePushAllPatchesForced(self): | |
| 857 """ | |
| 858 Private slot used to push all patches onto the stack on top | |
| 859 of local changes. | |
| 860 """ | |
| 861 self.__hgQueuePushPopPatches( | |
| 862 operation=Queues.PUSH, doAll=True, named=False, force=True) | |
| 863 | |
| 864 def __hgQueuePushPatches(self): | |
| 865 """ | |
| 866 Private slot used to push patches onto the stack until a named | |
| 867 one is at the top. | |
| 868 """ | |
| 869 self.__hgQueuePushPopPatches( | |
| 870 operation=Queues.PUSH, doAll=False, named=True) | |
| 871 | |
| 872 def __hgQueuePushPatchesForced(self): | |
| 873 """ | |
| 874 Private slot used to push patches onto the stack until a named | |
| 875 one is at the top on top of local changes. | |
| 876 """ | |
| 877 self.__hgQueuePushPopPatches( | |
| 878 operation=Queues.PUSH, doAll=False, named=True, force=True) | |
| 879 | |
| 880 def __hgQueuePopPatch(self): | |
| 881 """ | |
| 882 Private slot used to pop the current patch off the stack. | |
| 883 """ | |
| 884 self.__hgQueuePushPopPatches( | |
| 885 operation=Queues.POP, doAll=False, named=False) | |
| 886 | |
| 887 def __hgQueuePopPatchForced(self): | |
| 888 """ | |
| 889 Private slot used to pop the current patch off the stack forgetting | |
| 890 any local changes to patched files. | |
| 891 """ | |
| 892 self.__hgQueuePushPopPatches( | |
| 893 operation=Queues.POP, doAll=False, named=False, force=True) | |
| 894 | |
| 895 def __hgQueuePopAllPatches(self): | |
| 896 """ | |
| 897 Private slot used to pop all patches off the stack. | |
| 898 """ | |
| 899 self.__hgQueuePushPopPatches( | |
| 900 operation=Queues.POP, doAll=True, named=False) | |
| 901 | |
| 902 def __hgQueuePopAllPatchesForced(self): | |
| 903 """ | |
| 904 Private slot used to pop all patches off the stack forgetting | |
| 905 any local changes to patched files. | |
| 906 """ | |
| 907 self.__hgQueuePushPopPatches( | |
| 908 operation=Queues.POP, doAll=True, named=False, force=True) | |
| 909 | |
| 910 def __hgQueuePopPatches(self): | |
| 911 """ | |
| 912 Private slot used to pop patches off the stack until a named | |
| 913 one is at the top. | |
| 914 """ | |
| 915 self.__hgQueuePushPopPatches( | |
| 916 operation=Queues.POP, doAll=False, named=True) | |
| 917 | |
| 918 def __hgQueuePopPatchesForced(self): | |
| 919 """ | |
| 920 Private slot used to pop patches off the stack until a named | |
| 921 one is at the top forgetting any local changes to patched files. | |
| 922 """ | |
| 923 self.__hgQueuePushPopPatches( | |
| 924 operation=Queues.POP, doAll=False, named=True, force=True) | |
| 925 | |
| 926 def __hgQueueGotoPatch(self): | |
| 927 """ | |
| 928 Private slot used to push or pop patches until the a named one | |
| 929 is at the top of the stack. | |
| 930 """ | |
| 931 self.__hgQueuePushPopPatches( | |
| 932 operation=Queues.GOTO, doAll=False, named=True) | |
| 933 | |
| 934 def __hgQueueGotoPatchForced(self): | |
| 935 """ | |
| 936 Private slot used to push or pop patches until the a named one | |
| 937 is at the top of the stack overwriting local changes. | |
| 938 """ | |
| 939 self.__hgQueuePushPopPatches( | |
| 940 operation=Queues.GOTO, doAll=False, named=True, force=True) | |
| 941 | |
| 942 def __hgQueueListPatches(self): | |
| 943 """ | |
| 944 Private slot used to show a list of applied and unapplied patches. | |
| 945 """ | |
| 946 self.vcs.getExtensionObject("mq").hgQueueListPatches() | |
| 947 | |
| 948 def __hgQueueFinishAppliedPatches(self): | |
| 949 """ | |
| 950 Private slot used to finish all applied patches. | |
| 951 """ | |
| 952 self.vcs.getExtensionObject("mq").hgQueueFinishAppliedPatches() | |
| 953 | |
| 954 def __hgQueueRenamePatch(self): | |
| 955 """ | |
| 956 Private slot used to rename a patch. | |
| 957 """ | |
| 958 self.vcs.getExtensionObject("mq").hgQueueRenamePatch() | |
| 959 | |
| 960 def __hgQueueDeletePatch(self): | |
| 961 """ | |
| 962 Private slot used to delete a patch. | |
| 963 """ | |
| 964 self.vcs.getExtensionObject("mq").hgQueueDeletePatch() | |
| 965 | |
| 966 def __hgQueueFoldUnappliedPatches(self): | |
| 967 """ | |
| 968 Private slot used to fold patches into the current patch. | |
| 969 """ | |
| 970 self.vcs.getExtensionObject("mq").hgQueueFoldUnappliedPatches() | |
| 971 | |
| 972 def __hgQueueGuardsDefine(self): | |
| 973 """ | |
| 974 Private slot used to define guards for the current or a named patch. | |
| 975 """ | |
| 976 self.vcs.getExtensionObject("mq").hgQueueGuardsDefine() | |
| 977 | |
| 978 def __hgQueueGuardsDropAll(self): | |
| 979 """ | |
| 980 Private slot used to drop all guards of the current or a named patch. | |
| 981 """ | |
| 982 self.vcs.getExtensionObject("mq").hgQueueGuardsDropAll() | |
| 983 | |
| 984 def __hgQueueGuardsList(self): | |
| 985 """ | |
| 986 Private slot used to list the guards for the current or a named patch. | |
| 987 """ | |
| 988 self.vcs.getExtensionObject("mq").hgQueueGuardsList() | |
| 989 | |
| 990 def __hgQueueGuardsListAll(self): | |
| 991 """ | |
| 992 Private slot used to list all guards of all patches. | |
| 993 """ | |
| 994 self.vcs.getExtensionObject("mq").hgQueueGuardsListAll() | |
| 995 | |
| 996 def __hgQueueGuardsSetActive(self): | |
| 997 """ | |
| 998 Private slot used to set the active guards. | |
| 999 """ | |
| 1000 self.vcs.getExtensionObject("mq").hgQueueGuardsSetActive() | |
| 1001 | |
| 1002 def __hgQueueGuardsDeactivate(self): | |
| 1003 """ | |
| 1004 Private slot used to deactivate all active guards. | |
| 1005 """ | |
| 1006 self.vcs.getExtensionObject("mq").hgQueueGuardsDeactivate() | |
| 1007 | |
| 1008 def __hgQueueGuardsIdentifyActive(self): | |
| 1009 """ | |
| 1010 Private slot used to list all active guards. | |
| 1011 """ | |
| 1012 self.vcs.getExtensionObject("mq").hgQueueGuardsIdentifyActive() | |
| 1013 | |
| 1014 def __hgQueueCreateQueue(self): | |
| 1015 """ | |
| 1016 Private slot used to create a new queue. | |
| 1017 """ | |
| 1018 self.vcs.getExtensionObject("mq").hgQueueCreateRenameQueue(True) | |
| 1019 | |
| 1020 def __hgQueueRenameQueue(self): | |
| 1021 """ | |
| 1022 Private slot used to rename the active queue. | |
| 1023 """ | |
| 1024 self.vcs.getExtensionObject("mq").hgQueueCreateRenameQueue(False) | |
| 1025 | |
| 1026 def __hgQueueDeleteQueue(self): | |
| 1027 """ | |
| 1028 Private slot used to delete the reference to a queue. | |
| 1029 """ | |
| 1030 self.vcs.getExtensionObject("mq").hgQueueDeletePurgeActivateQueue( | |
| 1031 Queues.QUEUE_DELETE) | |
| 1032 | |
| 1033 def __hgQueuePurgeQueue(self): | |
| 1034 """ | |
| 1035 Private slot used to delete the reference to a queue and remove | |
| 1036 the patch directory. | |
| 1037 """ | |
| 1038 self.vcs.getExtensionObject("mq").hgQueueDeletePurgeActivateQueue( | |
| 1039 Queues.QUEUE_PURGE) | |
| 1040 | |
| 1041 def __hgQueueActivateQueue(self): | |
| 1042 """ | |
| 1043 Private slot used to set the active queue. | |
| 1044 """ | |
| 1045 self.vcs.getExtensionObject("mq").hgQueueDeletePurgeActivateQueue( | |
| 1046 Queues.QUEUE_ACTIVATE) | |
| 1047 | |
| 1048 def __hgQueueListQueues(self): | |
| 1049 """ | |
| 1050 Private slot used to list available queues. | |
| 1051 """ | |
| 1052 self.vcs.getExtensionObject("mq").hgQueueListQueues() | |
| 1053 | |
| 1054 def __hgQueueInit(self): | |
| 1055 """ | |
| 1056 Private slot to initialize a new queue repository. | |
| 1057 """ | |
| 1058 self.vcs.getExtensionObject("mq").hgQueueInit( | |
| 1059 self.project.getProjectPath()) | |
| 1060 | |
| 1061 def __hgQueueCommit(self): | |
| 1062 """ | |
| 1063 Private slot to commit changes in the queue repository. | |
| 1064 """ | |
| 1065 self.vcs.vcsCommit(self.project.getProjectPath(), "", mq=True) | |
| 1066 | |
| 1067 def __hgQueueStatus(self): | |
| 1068 """ | |
| 1069 Private slot to show the status of the queue repository. | |
| 1070 """ | |
| 1071 self.vcs.getExtensionObject("mq").hgQueueStatus( | |
| 1072 self.project.getProjectPath()) | |
| 1073 | |
| 1074 def __hgQueueSummary(self): | |
| 1075 """ | |
| 1076 Private slot to show a summary of the queue repository. | |
| 1077 """ | |
| 1078 self.vcs.hgSummary(mq=True) |
