ugitlibs/utilcontroller.py

   1 #!/usr/bin/env python
   2 from PyQt4.QtGui import QDialog
   3 from PyQt4.QtGui import QFont
   4 import utils
   5 import qtutils
   6 from qobserver import QObserver
   7 from views import BranchGUI
   8 from views import CommitGUI
   9 from views import OptionsGUI
  10
  11 def choose_branch(title, parent, branches):
  12                 dlg = BranchGUI(parent,branches)
  13                 dlg.setWindowTitle(dlg.tr(title))
  14                 return dlg.get_selected()
  15
  16 def select_commits(model, parent, revs, summaries):
  17         '''Use the CommitBrowser to select commits from a list.'''
  18         model = model.clone()
  19         model.set_revisions(revs)
  20         model.set_summaries(summaries)
  21         view = CommitGUI(parent)
  22         ctl = SelectCommitsController(model, view)
  23         return ctl.select_commits()
  24
  25 class SelectCommitsController(QObserver):
  26         def __init__(self, model, view):
  27                 QObserver.__init__(self, model, view)
  28                 self.connect(view.commitList, 'itemSelectionChanged()',
  29                                 self.commit_sha1_selected )
  30
  31                 if model.has_param('global.ugit.fontdiff'):
  32                         font = model.get_param('global.ugit.fontdiff')
  33                         if font:
  34                                 qf = QFont()
  35                                 qf.fromString(font)
  36                                 self.view.commitText.setFont(qf)
  37
  38         def select_commits(self):
  39                 summaries = self.model.get_summaries()
  40                 if not summaries:
  41                         msg = self.tr('No commits exist in this branch.')
  42                         self.show_output(msg)
  43                         return []
  44                 qtutils.set_items(self.view.commitList, summaries)
  45                 self.view.show()
  46                 if self.view.exec_() != QDialog.Accepted:
  47                         return []
  48                 revs = self.model.get_revisions()
  49                 list_widget = self.view.commitList
  50                 return qtutils.get_selection_list(list_widget, revs)
  51
  52         def commit_sha1_selected(self):
  53                 row, selected = qtutils.get_selected_row(self.view.commitList)
  54                 if not selected:
  55                         self.view.commitText.setText('')
  56                         self.view.revisionLine.setText('')
  57                         return
  58
  59                 # Get the sha1 and put it in the revision line
  60                 sha1 = self.model.get_revision_sha1(row)
  61                 self.view.revisionLine.setText(sha1)
  62                 self.view.revisionLine.selectAll()
  63
  64                 # Lookup the sha1's commit
  65                 commit_diff = self.model.get_commit_diff(sha1)
  66                 self.view.commitText.setText(commit_diff)
  67
  68                 # Copy the sha1 into the clipboard
  69                 qtutils.set_clipboard(sha1)
  70
  71 def update_options(model, parent):
  72         view = OptionsGUI(parent)
  73         ctl = OptionsController(model,view)
  74         view.show()
  75         return view.exec_() == QDialog.Accepted
  76
  77 class OptionsController(QObserver):
  78         def __init__(self,model,view):
  79
  80                 # used for telling about interactive font changes
  81                 self.original_model = model
  82                 model = model.clone()
  83
  84                 QObserver.__init__(self,model,view)
  85
  86                 model_to_view = {
  87                         'local.user.email': 'localEmailText',
  88                         'global.user.email': 'globalEmailText',
  89
  90                         'local.user.name':  'localNameText',
  91                         'global.user.name':  'globalNameText',
  92
  93                         'local.merge.summary': 'localSummarizeCheckBox',
  94                         'global.merge.summary': 'globalSummarizeCheckBox',
  95
  96                         'local.merge.diffstat': 'localShowDiffstatCheckBox',
  97                         'global.merge.diffstat': 'globalShowDiffstatCheckBox',
  98
  99                         'local.gui.diffcontext': 'localDiffContextSpin',
 100                         'global.gui.diffcontext': 'globalDiffContextSpin',
 101
 102                         'local.merge.verbosity': 'localVerbositySpin',
 103                         'global.merge.verbosity': 'globalVerbositySpin',
 104
 105                         'global.ugit.fontdiff.size': 'diffFontSpin',
 106                         'global.ugit.fontdiff':  'diffFontCombo',
 107
 108                         'global.ugit.fontui.size': 'mainFontSpin',
 109                         'global.ugit.fontui': 'mainFontCombo',
 110                 }
 111
 112                 for m,v in model_to_view.iteritems():
 113                         self.model_to_view(m,v)
 114
 115                 self.add_signals('textChanged(const QString&)',
 116                                 view.localNameText,
 117                                 view.globalNameText,
 118                                 view.localEmailText,
 119                                 view.globalEmailText)
 120
 121                 self.add_signals('stateChanged(int)',
 122                                 view.localSummarizeCheckBox,
 123                                 view.globalSummarizeCheckBox,
 124                                 view.localShowDiffstatCheckBox,
 125                                 view.globalShowDiffstatCheckBox)
 126
 127                 self.add_signals('valueChanged(int)',
 128                                 view.mainFontSpin,
 129                                 view.diffFontSpin,
 130                                 view.localDiffContextSpin,
 131                                 view.globalDiffContextSpin,
 132                                 view.localVerbositySpin,
 133                                 view.globalVerbositySpin)
 134
 135                 self.add_signals('currentFontChanged(const QFont&)',
 136                                 view.mainFontCombo,
 137                                 view.diffFontCombo)
 138
 139                 self.add_signals('released()',
 140                                 view.saveButton,
 141                                 view.cancelButton)
 142
 143                 self.add_actions('global.ugit.fontdiff.size', self.update_size)
 144                 self.add_actions('global.ugit.fontui.size', self.update_size)
 145                 self.add_actions('global.ugit.fontdiff', self.update_font)
 146                 self.add_actions('global.ugit.fontui', self.update_font)
 147
 148                 self.add_callbacks(saveButton = self.save_settings)
 149                 self.add_callbacks(cancelButton = self.restore_settings)
 150
 151                 view.localGroupBox.setTitle(
 152                         unicode(self.tr('%s Repository')) % model.get_project())
 153
 154                 self.refresh_view()
 155                 self.backup_model = self.model.clone()
 156
 157         def refresh_view(self):
 158
 159                 font = self.model.get_param('global.ugit.fontui')
 160                 if font:
 161                         size = int(font.split(',')[1])
 162                         self.view.mainFontSpin.setValue(size)
 163                         self.model.set_param('global.ugit.fontui.size', size)
 164                         ui_font = QFont()
 165                         ui_font.fromString(font)
 166                         self.view.mainFontCombo.setCurrentFont(ui_font)
 167
 168                 font = self.model.get_param('global.ugit.fontdiff')
 169                 if font:
 170                         size = int(font.split(',')[1])
 171                         self.view.diffFontSpin.setValue(size)
 172                         self.model.set_param('global.ugit.fontdiff.size', size)
 173                         diff_font = QFont()
 174                         diff_font.fromString(font)
 175                         self.view.diffFontCombo.setCurrentFont(diff_font)
 176
 177                 QObserver.refresh_view(self)
 178
 179
 180         def save_settings(self):
 181                 params_to_save = []
 182                 params = self.model.get_config_params()
 183                 for param in params:
 184                         value = self.model.get_param(param)
 185                         backup = self.backup_model.get_param(param)
 186                         if value != backup:
 187                                 params_to_save.append(param)
 188
 189                 for param in params_to_save:
 190                         self.model.save_config_param(param)
 191
 192                 self.original_model.copy_params(self.model, params_to_save)
 193
 194                 self.view.done(QDialog.Accepted)
 195
 196         def restore_settings(self):
 197                 params = self.backup_model.get_config_params()
 198                 self.model.copy_params(self.backup_model, params)
 199                 self.tell_parent_model()
 200                 self.view.reject()
 201
 202         def tell_parent_model(self):
 203                 for param in (
 204                                 'global.ugit.fontdiff',
 205                                 'global.ugit.fontui',
 206                                 'global.ugit.fontdiff.size',
 207                                 'global.ugit.fontui.size'):
 208                         self.original_model.set_param(param,
 209                                         self.model.get_param(param))
 210
 211         def update_font(self, *rest):
 212                 self.tell_parent_model()
 213                 return
 214
 215         def update_size(self, *rest):
 216                 combo = self.view.mainFontCombo
 217                 param = 'global.ugit.fontui'
 218                 default = str(combo.currentFont().toString())
 219                 self.model.apply_font_size(param, default)
 220
 221                 combo = self.view.diffFontCombo
 222                 param = 'global.ugit.fontdiff'
 223                 default = str(combo.currentFont().toString())
 224                 self.model.apply_font_size(param, default)
 225                 self.tell_parent_model()