ugit/controllers/util.py

   1 #!/usr/bin/env python
   2 import time
   3 from PyQt4.QtGui import QDialog
   4 from PyQt4.QtGui import QFont
   5
   6 from ugit import utils
   7 from ugit import qtutils
   8 from ugit.model import Model
   9 from ugit.views import BranchView
  10 from ugit.views import CommitView
  11 from ugit.views import OptionsView
  12 from ugit.views import LogView
  13 from ugit.qobserver import QObserver
  14
  15 def set_diff_font(model, widget):
  16         if model.has_param('global_ugit_fontdiff'):
  17                 font = model.get_param('global_ugit_fontdiff')
  18                 if not font: return
  19                 qf = QFont()
  20                 qf.fromString(font)
  21                 widget.setFont(qf)
  22
  23 def choose_branch(title, parent, branches):
  24         dlg = BranchView(parent,branches)
  25         dlg.setWindowTitle(dlg.tr(title))
  26         return dlg.get_selected()
  27
  28 #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  29 #+ The Commit Browser GUI Controller
  30 def select_commits(model, parent, title, revs, summaries):
  31         '''Use the CommitView to select commits from a list.'''
  32         model = model.clone()
  33         model.set_revisions(revs)
  34         model.set_summaries(summaries)
  35         view = CommitView(parent, title)
  36         ctl = SelectCommitsController(model, view)
  37         return ctl.select_commits()
  38
  39 class SelectCommitsController(QObserver):
  40         def __init__(self, model, view):
  41                 QObserver.__init__(self, model, view)
  42                 set_diff_font(model, self.view.commit_text)
  43                 self.connect(view.commit_list, 'itemSelectionChanged()',
  44                                 self.commit_sha1_selected )
  45
  46         def select_commits(self):
  47                 summaries = self.model.get_summaries()
  48                 if not summaries:
  49                         msg = self.tr('No commits exist in this branch.')
  50                         qtutils.show_output(msg)
  51                         return []
  52                 qtutils.set_items(self.view.commit_list, summaries)
  53                 self.view.show()
  54                 if self.view.exec_() != QDialog.Accepted:
  55                         return []
  56                 revs = self.model.get_revisions()
  57                 list_widget = self.view.commit_list
  58                 return qtutils.get_selection_list(list_widget, revs)
  59
  60         def commit_sha1_selected(self):
  61                 row, selected = qtutils.get_selected_row(self.view.commit_list)
  62                 if not selected:
  63                         self.view.commit_text.setText('')
  64                         self.view.revision.setText('')
  65                         return
  66
  67                 # Get the sha1 and put it in the revision line
  68                 sha1 = self.model.get_revision_sha1(row)
  69                 self.view.revision.setText(sha1)
  70                 self.view.revision.selectAll()
  71
  72                 # Lookup the sha1's commit
  73                 commit_diff = self.model.get_commit_diff(sha1)
  74                 self.view.commit_text.setText(commit_diff)
  75
  76                 # Copy the sha1 into the clipboard
  77                 qtutils.set_clipboard(sha1)
  78
  79
  80 #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  81 #+ The Options GUI Controller
  82 def update_options(model, parent):
  83         view = OptionsView(parent)
  84         ctl = OptionsController(model,view)
  85         view.show()
  86         return view.exec_() == QDialog.Accepted
  87
  88 class OptionsController(QObserver):
  89         '''ASSUMPTIONS:
  90         This controller assumes that the view's widgets are named
  91         the same as the model parameters.'''
  92
  93         def __init__(self,model,view):
  94
  95                 # used for telling about interactive font changes
  96                 self.original_model = model
  97                 model = model.clone()
  98
  99                 QObserver.__init__(self,model,view)
 100                 self.add_observables(
 101                         'local_user_email',
 102                         'local_user_name',
 103                         'local_merge_summary',
 104                         'local_merge_diffstat',
 105                         'local_merge_verbosity',
 106                         'local_gui_diffcontext',
 107                         'global_user_email',
 108                         'global_user_name',
 109                         'global_merge_summary',
 110                         'global_merge_diffstat',
 111                         'global_merge_verbosity',
 112                         'global_gui_diffcontext',
 113                         'global_ugit_fontdiff_size',
 114                         'global_ugit_fontdiff',
 115                         'global_ugit_fontui_size',
 116                         'global_ugit_fontui',
 117                         'global_ugit_historybrowser',
 118                         'global_ugit_savewindowsettings',
 119                         'global_ugit_saveatexit',
 120                         )
 121                 self.add_actions(global_ugit_fontdiff_size = self.update_size)
 122                 self.add_actions(global_ugit_fontui_size = self.update_size)
 123                 self.add_actions(global_ugit_fontdiff = self.tell_parent_model)
 124                 self.add_actions(global_ugit_fontui = self.tell_parent_model)
 125                 self.add_callbacks(save_button = self.save_settings)
 126                 self.connect(self.view, 'rejected()', self.restore_settings)
 127
 128                 self.refresh_view()
 129                 self.backup_model = self.model.clone()
 130
 131         def refresh_view(self):
 132                 font = self.model.get_param('global_ugit_fontui')
 133                 if font:
 134                         size = int(font.split(',')[1])
 135                         self.view.global_ugit_fontui_size.setValue(size)
 136                         self.model.set_global_ugit_fontui_size(size)
 137                         fontui = QFont()
 138                         fontui.fromString(font)
 139                         self.view.global_ugit_fontui.setCurrentFont(fontui)
 140
 141                 font = self.model.get_global_ugit_fontdiff()
 142                 if font:
 143                         size = int(font.split(',')[1])
 144                         self.view.global_ugit_fontdiff_size.setValue(size)
 145                         self.model.set_global_ugit_fontdiff_size(size)
 146                         fontdiff = QFont()
 147                         fontdiff.fromString(font)
 148                         self.view.global_ugit_fontdiff.setCurrentFont(fontdiff)
 149
 150                 self.view.local_groupbox.setTitle(
 151                         unicode(self.tr('%s Repository'))
 152                                         % self.model.get_project())
 153                 QObserver.refresh_view(self)
 154
 155         # save button
 156         def save_settings(self):
 157                 params_to_save = []
 158                 params = self.model.get_config_params()
 159                 for param in params:
 160                         value = self.model.get_param(param)
 161                         backup = self.backup_model.get_param(param)
 162                         if value != backup:
 163                                 params_to_save.append(param)
 164                 for param in params_to_save:
 165                         self.model.save_config_param(param)
 166
 167                 self.original_model.copy_params(self.model, params_to_save)
 168                 self.view.done(QDialog.Accepted)
 169
 170         # cancel button -> undo changes
 171         def restore_settings(self):
 172                 params = self.backup_model.get_config_params()
 173                 self.model.copy_params(self.backup_model, params)
 174                 self.tell_parent_model()
 175
 176         def tell_parent_model(self,*rest):
 177                 params= (
 178                                 'global_ugit_fontdiff',
 179                                 'global_ugit_fontui',
 180                                 'global_ugit_fontdiff_size',
 181                                 'global_ugit_fontui_size',
 182                                 'global_ugit_savewindowsettings',
 183                                 'global_ugit_saveatexit',
 184                         )
 185                 for param in params:
 186                         self.original_model.set_param(
 187                                 param, self.model.get_param(param))
 188
 189         def update_size(self, *rest):
 190                 combo = self.view.global_ugit_fontui
 191                 param = str(combo.objectName())
 192                 default = str(combo.currentFont().toString())
 193                 self.model.apply_font_size(param, default)
 194
 195                 combo = self.view.global_ugit_fontdiff
 196                 param = str(combo.objectName())
 197                 default = str(combo.currentFont().toString())
 198                 self.model.apply_font_size(param, default)
 199
 200                 self.tell_parent_model()
 201
 202 #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 203 #+ The Log GUI Controller
 204 def logger():
 205         model = Model( search_text = '' )
 206         view = LogView(None)
 207         ctl = LogController(model,view)
 208         return view
 209
 210 class LogController(QObserver):
 211         def __init__(self, model, view):
 212                 QObserver.__init__(self, model, view)
 213
 214                 self.add_observables('search_text')
 215                 self.add_actions(search_text = self.insta_search)
 216                 self.add_callbacks(
 217                                 clear_button = self.clear,
 218                                 next_button = self.next,
 219                                 prev_button = self.prev,
 220                                 )
 221                 self.connect(self.view.output_text,
 222                                 'cursorPositionChanged()',
 223                                 self.cursor_position_changed)
 224                 self.search_offset = 0
 225
 226         def insta_search(self,*rest):
 227                 self.search_offset = 0
 228                 txt = self.model.get_search_text().lower()
 229                 if len(txt.strip()):
 230                         self.next()
 231                 else:
 232                         cursor = self.view.output_text.textCursor()
 233                         cursor.clearSelection()
 234                         self.view.output_text.setTextCursor(cursor)
 235
 236         def clear(self):
 237                 self.view.output_text.clear()
 238                 self.search_offset = 0
 239
 240         def next(self):
 241                 text = self.model.get_search_text().lower().strip()
 242                 if not text: return
 243                 output = str(self.view.output_text.toPlainText())
 244                 if self.search_offset + len(text) > len(output):
 245                         answer = qtutils.question(
 246                                         self.view,
 247                                         unicode(self.tr("%s not found")) % text,
 248                                         unicode(self.tr(
 249                                                 "Could not find '%s'.\n"
 250                                                 "Search from the beginning?"
 251                                         )) % text,
 252                                         default=False)
 253
 254                         if answer:
 255                                 self.search_offset = 0
 256                         else:
 257                                 return
 258
 259                 find_in = output[self.search_offset:].lower()
 260                 try:
 261                         index = find_in.index(text)
 262                 except:
 263                         self.search_offset = 0
 264                         answer = qtutils.question(
 265                                         self.view,
 266                                         unicode(self.tr("%s not found")) % text,
 267                                         unicode(self.tr(
 268                                                 "Could not find '%s'.\n"
 269                                                 "Search from the beginning?"
 270                                                 )) % text,
 271                                         default=False)
 272                         if answer:
 273                                 self.next()
 274                         return
 275                 cursor = self.view.output_text.textCursor()
 276                 offset = self.search_offset + index
 277                 new_offset = offset + len(text)
 278
 279                 cursor.setPosition(offset)
 280                 cursor.setPosition(new_offset, cursor.KeepAnchor)
 281
 282                 self.view.output_text.setTextCursor(cursor)
 283                 self.search_offset = new_offset
 284
 285         def prev(self):
 286                 text = self.model.get_search_text().lower().strip()
 287                 if not text: return
 288                 output = str(self.view.output_text.toPlainText())
 289                 if self.search_offset == 0:
 290                         self.search_offset = len(output)
 291
 292                 find_in = output[:self.search_offset].lower()
 293                 try:
 294                         offset = find_in.rindex(text)
 295                 except:
 296                         self.search_offset = 0
 297                         if qtutils.question(
 298                                 self.view,
 299                                 unicode(self.tr("%s not found")) % text,
 300                                 unicode(self.tr("Could not find '%s'.\n"
 301                                                 "Search from the end?"
 302                                                 )) % text):
 303                                 self.prev()
 304                         return
 305                 cursor = self.view.output_text.textCursor()
 306                 new_offset = offset + len(text)
 307
 308                 cursor.setPosition(offset)
 309                 cursor.setPosition(new_offset, cursor.KeepAnchor)
 310
 311                 self.view.output_text.setTextCursor(cursor)
 312                 self.search_offset = offset
 313
 314         def cursor_position_changed(self):
 315                 cursor = self.view.output_text.textCursor()
 316                 self.search_offset = cursor.selectionStart()