/b-gtk/fix-viz

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/b-gtk/fix-viz

« back to all changes in this revision

Viewing changes to branch.py

Add options to viz treeview to not show the line graph, and to only show the main line.
Set the revision browser to use these options.

Show diffs side-by-side

added added

removed removed

Lines of Context:
branch.py
16
16
 
17
17
import os
18
18
 
19
 
from gi.repository import Gtk
20
 
 
21
 
from bzrlib import (
22
 
    errors,
23
 
    )
 
19
try:
 
20
    import pygtk
 
21
    pygtk.require("2.0")
 
22
except:
 
23
    pass
 
24
 
 
25
import gtk
 
26
 
 
27
from errors import show_bzr_error
 
28
 
24
29
from bzrlib.branch import Branch
25
 
from bzrlib.transport import get_transport
26
 
 
27
 
from bzrlib.plugins.gtk.dialog import error_dialog, info_dialog
28
 
from bzrlib.plugins.gtk.errors import show_bzr_error
29
 
from bzrlib.plugins.gtk.i18n import _i18n
30
 
from bzrlib.plugins.gtk.branchbox import BranchSelectionBox
31
 
 
32
 
 
33
 
class BranchDialog(Gtk.Dialog):
 
30
import bzrlib.errors as errors
 
31
 
 
32
from dialog import error_dialog, info_dialog
 
33
 
 
34
from branchbox import BranchSelectionBox
 
35
 
 
36
class BranchDialog(gtk.Dialog):
34
37
    """ New implementation of the Branch dialog. """
35
38
 
36
39
    def __init__(self, path=None, parent=None, remote_path=None):
37
40
        """ Initialize the Branch dialog. """
38
 
        super(BranchDialog, self).__init__(
39
 
            title="Branch - Olive", parent=parent, flags=0,
40
 
            buttons=(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL))
41
 
 
 
41
        gtk.Dialog.__init__(self, title="Branch - Olive",
 
42
                                  parent=parent,
 
43
                                  flags=0,
 
44
                                  buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
 
45
        
42
46
        # Get arguments
43
47
        self.path = path
44
 
 
 
48
        
45
49
        # Create the widgets
46
 
        self._button_branch = Gtk.Button(_i18n("_Branch"), use_underline=True)
 
50
        self._button_branch = gtk.Button(_("_Branch"), use_underline=True)
47
51
        self._remote_branch = BranchSelectionBox()
48
 
        self._button_revision = Gtk.Button('')
49
 
        self._label_location = Gtk.Label(label=_i18n("Branch location:"))
 
52
        self._button_revision = gtk.Button('')
 
53
        self._label_location = gtk.Label(_("Branch location:"))
50
54
        self._label_location.set_alignment(0, 0.5)
51
 
        self._label_destination = Gtk.Label(label=_i18n("Destination:"))
52
 
        self._label_nick = Gtk.Label(label=_i18n("Branck nick:"))
53
 
        self._label_revision = Gtk.Label(label=_i18n("Revision:"))
54
 
        self._filechooser = Gtk.FileChooserButton(_i18n("Please select a folder"))
55
 
        self._filechooser.set_action(Gtk.FileChooserAction.SELECT_FOLDER)
56
 
        self._hbox_revision = Gtk.HBox()
57
 
        self._entry_revision = Gtk.Entry()
58
 
        self._entry_nick = Gtk.Entry()
59
 
 
 
55
        self._label_destination = gtk.Label(_("Destination:"))
 
56
        self._label_nick = gtk.Label(_("Branck nick:"))
 
57
        self._label_revision = gtk.Label(_("Revision:"))
 
58
        self._filechooser = gtk.FileChooserButton(_("Please select a folder"))
 
59
        self._filechooser.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
 
60
        self._hbox_revision = gtk.HBox()
 
61
        self._entry_revision = gtk.Entry()
 
62
        self._entry_nick = gtk.Entry()
 
63
        
60
64
        # Set callbacks
61
65
        self._button_branch.connect('clicked', self._on_branch_clicked)
62
66
        self._button_revision.connect('clicked', self._on_revision_clicked)
63
67
        self._remote_branch.connect('branch-changed', self._on_branch_changed)
64
68
 
65
69
        # Create the table and pack the widgets into it
66
 
        self._table = Gtk.Table(rows=3, columns=2)
 
70
        self._table = gtk.Table(rows=3, columns=2)
67
71
        self._table.attach(self._label_location, 0, 1, 0, 1)
68
72
        self._table.attach(self._remote_branch, 1, 2, 0, 1)
69
73
        self._table.attach(self._label_destination, 0, 1, 1, 2)
72
76
        self._table.attach(self._filechooser, 1, 2, 1, 2)
73
77
        self._table.attach(self._entry_nick, 1, 2, 2, 3)
74
78
        self._table.attach(self._hbox_revision, 1, 2, 3, 4)
75
 
 
 
79
        
76
80
        # Set properties
77
 
        self._image_browse = Gtk.Image()
78
 
        self._image_browse.set_from_stock(Gtk.STOCK_OPEN, Gtk.IconSize.BUTTON)
 
81
        self._image_browse = gtk.Image()
 
82
        self._image_browse.set_from_stock(gtk.STOCK_OPEN, gtk.ICON_SIZE_BUTTON)
79
83
        self._button_revision.set_image(self._image_browse)
80
84
        self._button_revision.set_sensitive(False)
81
85
        self._label_destination.set_alignment(0, 0.5)
83
87
        self._label_revision.set_alignment(0, 0.5)
84
88
        self._table.set_row_spacings(3)
85
89
        self._table.set_col_spacings(3)
86
 
        self.get_content_area().set_spacing(3)
 
90
        self.vbox.set_spacing(3)
87
91
        if remote_path is not None:
88
92
            self._remote_branch.set_url(remote_path)
89
93
        if self.path is not None:
90
94
            self._filechooser.set_filename(self.path)
91
 
 
 
95
        
92
96
        # Pack some widgets
93
 
        self._hbox_revision.pack_start(self._entry_revision, True, True, 0)
94
 
        self._hbox_revision.pack_start(self._button_revision, False, False, 0)
95
 
        self.get_content_area().add(self._table)
96
 
        self.action_area.pack_end(self._button_branch, False, False, 0)
97
 
 
 
97
        self._hbox_revision.pack_start(self._entry_revision, True, True)
 
98
        self._hbox_revision.pack_start(self._button_revision, False, False)
 
99
        self.vbox.add(self._table)
 
100
        self.action_area.pack_end(self._button_branch)
 
101
        
98
102
        # Show the dialog
99
 
        self.get_content_area().show_all()
100
 
 
 
103
        self.vbox.show_all()
 
104
    
101
105
    def _get_last_revno(self):
102
106
        """ Get the revno of the last revision (if any). """
103
107
        try:
105
109
            return br.revno()
106
110
        except:
107
111
            pass
108
 
 
 
112
    
109
113
    def _on_revision_clicked(self, button):
110
114
        """ Browse for revision button clicked handler. """
111
115
        from revbrowser import RevisionBrowser
112
 
 
113
 
 
 
116
        
 
117
        
114
118
        try:
115
119
            br = self._remote_branch.get_branch()
116
120
        except:
117
121
            return
118
122
        revb = RevisionBrowser(br, self)
119
123
        response = revb.run()
120
 
        if response != Gtk.ResponseType.NONE:
 
124
        if response != gtk.RESPONSE_NONE:
121
125
            revb.hide()
122
 
 
123
 
            if response == Gtk.ResponseType.OK:
 
126
    
 
127
            if response == gtk.RESPONSE_OK:
124
128
                if revb.selected_revno is not None:
125
129
                    self._entry_revision.set_text(revb.selected_revno)
126
 
 
 
130
        
127
131
            revb.destroy()
128
 
 
 
132
    
129
133
    @show_bzr_error
130
134
    def _on_branch_clicked(self, button):
131
135
        """ Branch button clicked handler. """
132
136
        location = self._remote_branch.get_url()
133
137
        if location is '':
134
 
            error_dialog(_i18n('Missing branch location'),
135
 
                         _i18n('You must specify a branch location.'))
 
138
            error_dialog(_('Missing branch location'),
 
139
                         _('You must specify a branch location.'))
136
140
            return
137
 
 
 
141
        
138
142
        destination = self._filechooser.get_filename()
139
143
        try:
140
144
            revno = int(self._entry_revision.get_text())
141
145
        except:
142
146
            revno = None
143
 
 
 
147
        
144
148
        nick = self._entry_nick.get_text()
145
149
        if nick is '':
146
150
            nick = os.path.basename(location.rstrip("/\\"))
147
 
 
 
151
        
148
152
        br_from = Branch.open(location)
149
 
 
 
153
        
150
154
        br_from.lock_read()
151
155
        try:
 
156
            from bzrlib.transport import get_transport
 
157
 
152
158
            revision_id = br_from.get_rev_id(revno)
153
159
 
154
160
            basis_dir = None
155
 
 
 
161
            
156
162
            to_location = destination + os.sep + nick
157
163
            to_transport = get_transport(to_location)
158
 
 
 
164
            
159
165
            to_transport.mkdir('.')
160
 
 
 
166
            
161
167
            try:
162
168
                # preserve whatever source format we have.
163
169
                dir = br_from.bzrdir.sprout(to_transport.base,
170
176
                raise
171
177
        finally:
172
178
            br_from.unlock()
173
 
 
174
 
        info_dialog(_i18n('Branching successful'),
175
 
                    _i18n('%d revision(s) branched.') % revs)
176
 
 
177
 
        self.response(Gtk.ResponseType.OK)
178
 
 
 
179
                
 
180
        self._history.add_entry(location)
 
181
        info_dialog(_('Branching successful'),
 
182
                    _('%d revision(s) branched.') % revs)
 
183
        
 
184
        self.response(gtk.RESPONSE_OK)
 
185
    
179
186
    def _on_branch_changed(self, widget, event):
180
187
        """ We try to get the last revision if focus lost. """
181
188
        rev = self._get_last_revno()
182
189
        if rev is None:
183
 
            self._entry_revision.set_text(_i18n('N/A'))
 
190
            self._entry_revision.set_text(_('N/A'))
184
191
            self._button_revision.set_sensitive(False)
185
192
        else:
186
193
            self._entry_revision.set_text(str(rev))