/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 annotate/gannotate.py

  • Committer: Daniel Schierbeck
  • Date: 2008-01-13 14:12:49 UTC
  • mto: (423.1.2 trunk)
  • mto: This revision was merged to the branch mainline in revision 429.
  • Revision ID: daniel.schierbeck@gmail.com-20080113141249-gd0i2lknr3yik55r
Moved branch view to its own package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
annotate/gannotate.py
21
21
import gobject
22
22
import gtk
23
23
import pango
 
24
import re
24
25
 
 
26
from bzrlib import patiencediff, tsort
25
27
from bzrlib.errors import NoSuchRevision
 
28
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
26
29
 
27
30
from colormap import AnnotateColorMap, AnnotateColorSaturation
28
 
from logview import LogView
29
 
from spanselector import SpanSelector
 
31
from bzrlib.plugins.gtk.revisionview import RevisionView
 
32
from bzrlib.plugins.gtk.window import Window
30
33
 
31
34
 
32
35
(
39
42
) = range(6)
40
43
 
41
44
 
42
 
class GAnnotateWindow(gtk.Window):
 
45
class GAnnotateWindow(Window):
43
46
    """Annotate window."""
44
47
 
45
 
    def __init__(self, all=False, plain=False):
 
48
    def __init__(self, all=False, plain=False, parent=None):
46
49
        self.all = all
47
50
        self.plain = plain
48
51
        
49
 
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
 
52
        Window.__init__(self, parent)
50
53
        
51
54
        self.set_icon(self.render_icon(gtk.STOCK_FIND, gtk.ICON_SIZE_BUTTON))
52
55
        self.annotate_colormap = AnnotateColorSaturation()
53
56
 
54
57
        self._create()
55
 
 
56
 
        if self.plain:
57
 
            self.span_selector.hide()
58
 
 
59
 
    def annotate(self, branch, file_id):
60
58
        self.revisions = {}
 
59
        self.history = []
 
60
        self._no_back = set()
 
61
 
 
62
    def annotate(self, tree, branch, file_id):
 
63
        self.annotations = []
 
64
        self.branch = branch
 
65
        self.tree = tree
 
66
        self.file_id = file_id
 
67
        self.revisionview.set_file_id(file_id)
 
68
        self.revision_id = getattr(tree, 'get_revision_id', 
 
69
                                   lambda: CURRENT_REVISION)()
61
70
        
62
 
        # [revision id, line number, committer, revno, highlight color, line]
 
71
        # [revision id, line number, author, revno, highlight color, line]
63
72
        self.annomodel = gtk.ListStore(gobject.TYPE_STRING,
64
73
                                       gobject.TYPE_STRING,
65
74
                                       gobject.TYPE_STRING,
72
81
            branch.lock_read()
73
82
            branch.repository.lock_read()
74
83
            for line_no, (revision, revno, line)\
75
 
                    in enumerate(self._annotate(branch, file_id)):
 
84
                    in enumerate(self._annotate(tree, file_id)):
76
85
                if revision.revision_id == last_seen and not self.all:
77
 
                    revno = committer = ""
 
86
                    revno = author = ""
78
87
                else:
79
88
                    last_seen = revision.revision_id
80
 
                    committer = revision.committer
 
89
                    author = revision.get_apparent_author()
81
90
 
82
91
                if revision.revision_id not in self.revisions:
83
92
                    self.revisions[revision.revision_id] = revision
84
93
 
85
94
                self.annomodel.append([revision.revision_id,
86
95
                                       line_no + 1,
87
 
                                       committer,
 
96
                                       author,
88
97
                                       revno,
89
98
                                       None,
90
99
                                       line.rstrip("\r\n")
91
100
                                      ])
 
101
                self.annotations.append(revision)
92
102
 
93
103
            if not self.plain:
94
 
                self._set_oldest_newest()
95
 
                # Recall that calling activate_default will emit "span-changed",
96
 
                # so self._span_changed_cb will take care of initial highlighting
97
 
                self.span_selector.activate_default()
 
104
                now = time.time()
 
105
                self.annomodel.foreach(self._highlight_annotation, now)
98
106
        finally:
99
107
            branch.repository.unlock()
100
108
            branch.unlock()
109
117
            # bar?
110
118
            print("gannotate: Line number %d does't exist. Defaulting to "
111
119
                  "line 1." % lineno)
 
120
            return
112
121
        else:
113
122
            row = lineno - 1
114
123
 
115
124
        self.annoview.set_cursor(row)
 
125
        self.annoview.scroll_to_cell(row, use_align=True)
116
126
 
117
 
    def _annotate(self, branch, file_id):
118
 
        rev_hist = branch.revision_history()
119
 
        repository = branch.repository
120
 
        rev_tree = repository.revision_tree(branch.last_revision())
121
 
        rev_id = rev_tree.inventory[file_id].revision
122
 
        weave = repository.weave_store.get_weave(file_id,
123
 
                                                 branch.get_transaction())
 
127
    def _dotted_revnos(self, repository, revision_id):
 
128
        """Return a dict of revision_id -> dotted revno
124
129
        
125
 
        revision_cache = RevisionCache(repository)
126
 
        for origin, text in weave.annotate_iter(rev_id):
 
130
        :param repository: The repository to get the graph from
 
131
        :param revision_id: The last revision for which this info is needed
 
132
        """
 
133
        graph = repository.get_revision_graph(revision_id)
 
134
        dotted = {}
 
135
        for n, revision_id, d, revno, e in tsort.merge_sort(graph, 
 
136
            revision_id, generate_revno=True):
 
137
            dotted[revision_id] = '.'.join(str(num) for num in revno)
 
138
        return dotted
 
139
 
 
140
    def _annotate(self, tree, file_id):
 
141
        current_revision = FakeRevision(CURRENT_REVISION)
 
142
        current_revision.committer = self.branch.get_config().username()
 
143
        current_revision.timestamp = time.time()
 
144
        current_revision.message = '[Not yet committed]'
 
145
        current_revision.parent_ids = tree.get_parent_ids()
 
146
        current_revision.properties['branch-nick'] = self.branch.nick
 
147
        current_revno = '%d?' % (self.branch.revno() + 1)
 
148
        repository = self.branch.repository
 
149
        if self.revision_id == CURRENT_REVISION:
 
150
            revision_id = self.branch.last_revision()
 
151
        else:
 
152
            revision_id = self.revision_id
 
153
        dotted = self._dotted_revnos(repository, revision_id)
 
154
        revision_cache = RevisionCache(repository, self.revisions)
 
155
        for origin, text in tree.annotate_iter(file_id):
127
156
            rev_id = origin
128
 
            try:
129
 
                revision = revision_cache.get_revision(rev_id)
130
 
                if rev_id in rev_hist:
131
 
                    revno = branch.revision_id_to_revno(rev_id)
132
 
                else:
133
 
                    revno = "merge"
134
 
            except NoSuchRevision:
135
 
                revision = NoneRevision(rev_id)
136
 
                revno = "?"
 
157
            if rev_id == CURRENT_REVISION:
 
158
                revision = current_revision
 
159
                revno = current_revno
 
160
            else:
 
161
                try:
 
162
                    revision = revision_cache.get_revision(rev_id)
 
163
                    revno = dotted.get(rev_id, 'merge')
 
164
                    if len(revno) > 15:
 
165
                        revno = 'merge'
 
166
                except NoSuchRevision:
 
167
                    revision = FakeRevision(rev_id)
 
168
                    revno = "?"
137
169
 
138
170
            yield revision, revno, text
139
171
 
140
 
    def _set_oldest_newest(self):
141
 
        rev_dates = map(lambda i: self.revisions[i].timestamp, self.revisions)
142
 
        oldest = min(rev_dates)
143
 
        newest = max(rev_dates)
144
 
 
145
 
        span = self._span_from_seconds(time.time() - oldest)
146
 
        self.span_selector.set_to_oldest_span(span)
147
 
        
148
 
        span = self._span_from_seconds(newest - oldest)
149
 
        self.span_selector.set_newest_to_oldest_span(span)
150
 
 
151
 
    def _span_from_seconds(self, seconds):
152
 
        return (seconds / (24 * 60 * 60))
153
 
    
154
 
    def _span_changed_cb(self, w, span):
155
 
        self.annotate_colormap.set_span(span)
156
 
        now = time.time()
157
 
        self.annomodel.foreach(self._highlight_annotation, now)
158
 
 
159
172
    def _highlight_annotation(self, model, path, iter, now):
160
173
        revision_id, = model.get(iter, REVISION_ID_COL)
161
174
        revision = self.revisions[revision_id]
162
175
        model.set(iter, HIGHLIGHT_COLOR_COL,
163
176
                  self.annotate_colormap.get_color(revision, now))
164
177
 
165
 
    def _show_log(self, w):
 
178
    def _selected_revision(self):
166
179
        (path, col) = self.annoview.get_cursor()
167
 
        rev_id = self.annomodel[path][REVISION_ID_COL]
168
 
        self.logview.set_revision(self.revisions[rev_id])
 
180
        if path is None:
 
181
            return None
 
182
        return self.annomodel[path][REVISION_ID_COL]
 
183
 
 
184
    def _activate_selected_revision(self, w):
 
185
        rev_id = self._selected_revision()
 
186
        if rev_id is None:
 
187
            return
 
188
        selected = self.revisions[rev_id]
 
189
        self.revisionview.set_revision(selected)
 
190
        if (len(selected.parent_ids) != 0 and selected.parent_ids[0] not in
 
191
            self._no_back):
 
192
            enable_back = True
 
193
        else:
 
194
            enable_back = False
 
195
        self.back_button.set_sensitive(enable_back)
169
196
 
170
197
    def _create(self):
171
 
        self.logview = self._create_log_view()
 
198
        self.revisionview = self._create_log_view()
172
199
        self.annoview = self._create_annotate_view()
173
 
        self.span_selector = self._create_span_selector()
174
200
 
175
 
        vbox = gtk.VBox(False, 12)
176
 
        vbox.set_border_width(12)
 
201
        vbox = gtk.VBox(False)
177
202
        vbox.show()
178
203
 
179
204
        sw = gtk.ScrolledWindow()
180
205
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
181
206
        sw.set_shadow_type(gtk.SHADOW_IN)
182
207
        sw.add(self.annoview)
 
208
        self.annoview.gwindow = self
183
209
        sw.show()
 
210
 
 
211
        swbox = gtk.VBox()
 
212
        swbox.pack_start(sw)
 
213
        swbox.show()
 
214
 
 
215
        hbox = gtk.HBox(False, 6)
 
216
        self.back_button = self._create_back_button()
 
217
        hbox.pack_start(self.back_button, expand=False, fill=True)
 
218
        self.forward_button = self._create_forward_button()
 
219
        hbox.pack_start(self.forward_button, expand=False, fill=True)
 
220
        hbox.show()
 
221
        vbox.pack_start(hbox, expand=False, fill=True)
184
222
        
185
223
        self.pane = pane = gtk.VPaned()
186
 
        pane.add1(sw)
187
 
        pane.add2(self.logview)
 
224
        pane.add1(swbox)
 
225
        pane.add2(self.revisionview)
188
226
        pane.show()
189
227
        vbox.pack_start(pane, expand=True, fill=True)
190
 
        
191
 
        hbox = gtk.HBox(True, 6)
192
 
        hbox.pack_start(self.span_selector, expand=False, fill=True)
193
 
        hbox.pack_start(self._create_button_box(), expand=False, fill=True)
194
 
        hbox.show()
195
 
        vbox.pack_start(hbox, expand=False, fill=True)
 
228
 
 
229
        self._search = SearchBox()
 
230
        swbox.pack_start(self._search, expand=False, fill=True)
 
231
        accels = gtk.AccelGroup()
 
232
        accels.connect_group(gtk.keysyms.f, gtk.gdk.CONTROL_MASK,
 
233
                             gtk.ACCEL_LOCKED,
 
234
                             self._search_by_text)
 
235
        accels.connect_group(gtk.keysyms.g, gtk.gdk.CONTROL_MASK,
 
236
                             gtk.ACCEL_LOCKED,
 
237
                             self._search_by_line)
 
238
        self.add_accel_group(accels)
196
239
 
197
240
        self.add(vbox)
198
241
 
 
242
    def _search_by_text(self, accel_group, window, key, modifiers):
 
243
        self._search.show_for('text')
 
244
        self._search.set_target(self.annoview, TEXT_LINE_COL)
 
245
 
 
246
    def _search_by_line(self, accel_group, window, key, modifiers):
 
247
        self._search.show_for('line')
 
248
        self._search.set_target(self.annoview, LINE_NUM_COL)
 
249
 
 
250
    def row_diff(self, tv, path, tvc):
 
251
        row = path[0]
 
252
        revision = self.annotations[row]
 
253
        repository = self.branch.repository
 
254
        if revision.revision_id == CURRENT_REVISION:
 
255
            tree1 = self.tree
 
256
            tree2 = self.tree.basis_tree()
 
257
        else:
 
258
            tree1 = repository.revision_tree(revision.revision_id)
 
259
            if len(revision.parent_ids) > 0:
 
260
                tree2 = repository.revision_tree(revision.parent_ids[0])
 
261
            else:
 
262
                tree2 = repository.revision_tree(NULL_REVISION)
 
263
        from bzrlib.plugins.gtk.diff import DiffWindow
 
264
        window = DiffWindow()
 
265
        window.set_diff("Diff for row %d" % (row+1), tree1, tree2)
 
266
        window.set_file(tree1.id2path(self.file_id))
 
267
        window.show()
 
268
 
 
269
 
199
270
    def _create_annotate_view(self):
200
271
        tv = gtk.TreeView()
201
272
        tv.set_rules_hint(False)
202
 
        tv.connect("cursor-changed", self._show_log)
 
273
        tv.connect("cursor-changed", self._activate_selected_revision)
203
274
        tv.show()
 
275
        tv.connect("row-activated", self.row_diff)
204
276
 
205
277
        cell = gtk.CellRendererText()
206
278
        cell.set_property("xalign", 1.0)
247
319
        col.add_attribute(cell, "text", TEXT_LINE_COL)
248
320
        tv.append_column(col)
249
321
 
 
322
        # FIXME: Now that C-f is now used for search by text we
 
323
        # may as well disable the auto search.
250
324
        tv.set_search_column(LINE_NUM_COL)
251
 
        
 
325
 
252
326
        return tv
253
327
 
254
 
    def _create_span_selector(self):
255
 
        ss = SpanSelector()
256
 
        ss.connect("span-changed", self._span_changed_cb)
257
 
        ss.show()
258
 
 
259
 
        return ss
260
 
 
261
328
    def _create_log_view(self):
262
 
        lv = LogView()
 
329
        lv = RevisionView()
263
330
        lv.show()
264
 
 
265
331
        return lv
266
332
 
267
 
    def _create_button_box(self):
268
 
        box = gtk.HButtonBox()
269
 
        box.set_layout(gtk.BUTTONBOX_END)
270
 
        box.show()
271
 
        
272
 
        button = gtk.Button()
273
 
        button.set_use_stock(True)
274
 
        button.set_label("gtk-close")
275
 
        button.connect("clicked", lambda w: self.destroy())
276
 
        button.show()
277
 
        
278
 
        box.pack_start(button, expand=False, fill=False)
279
 
 
280
 
        return box
281
 
 
282
 
 
283
 
class NoneRevision:
 
333
    def _create_back_button(self):
 
334
        button = gtk.Button()
 
335
        button.set_use_stock(True)
 
336
        button.set_label("gtk-go-back")
 
337
        button.connect("clicked", lambda w: self.go_back())
 
338
        button.set_relief(gtk.RELIEF_NONE)
 
339
        button.show()
 
340
        return button
 
341
 
 
342
    def _create_forward_button(self):
 
343
        button = gtk.Button()
 
344
        button.set_use_stock(True)
 
345
        button.set_label("gtk-go-forward")
 
346
        button.connect("clicked", lambda w: self.go_forward())
 
347
        button.set_relief(gtk.RELIEF_NONE)
 
348
        button.show()
 
349
        button.set_sensitive(False)
 
350
        return button
 
351
 
 
352
    def go_back(self):
 
353
        last_tree = self.tree
 
354
        rev_id = self._selected_revision()
 
355
        parent_id = self.revisions[rev_id].parent_ids[0]
 
356
        target_tree = self.branch.repository.revision_tree(parent_id)
 
357
        if self._go(target_tree):
 
358
            self.history.append(last_tree)
 
359
            self.forward_button.set_sensitive(True)
 
360
        else:
 
361
            self._no_back.add(parent_id)
 
362
            self.back_button.set_sensitive(False)
 
363
 
 
364
    def go_forward(self):
 
365
        if len(self.history) == 0:
 
366
            return
 
367
        target_tree = self.history.pop()
 
368
        if len(self.history) == 0:
 
369
            self.forward_button.set_sensitive(False)
 
370
        self._go(target_tree)
 
371
 
 
372
    def _go(self, target_tree):
 
373
        rev_id = self._selected_revision()
 
374
        if self.file_id in target_tree:
 
375
            offset = self.get_scroll_offset(target_tree)
 
376
            (row,), col = self.annoview.get_cursor()
 
377
            self.annotate(target_tree, self.branch, self.file_id)
 
378
            new_row = row+offset
 
379
            if new_row < 0:
 
380
                new_row = 0
 
381
            self.annoview.set_cursor(new_row)
 
382
            return True
 
383
        else:
 
384
            return False
 
385
 
 
386
    def get_scroll_offset(self, tree):
 
387
        old = self.tree.get_file(self.file_id)
 
388
        new = tree.get_file(self.file_id)
 
389
        (row,), col = self.annoview.get_cursor()
 
390
        matcher = patiencediff.PatienceSequenceMatcher(None, old.readlines(),
 
391
                                                       new.readlines())
 
392
        for i, j, n in matcher.get_matching_blocks():
 
393
            if i + n >= row:
 
394
                return j - i
 
395
 
 
396
 
 
397
class FakeRevision:
284
398
    """ A fake revision.
285
399
 
286
400
    For when a revision is referenced but not present.
287
401
    """
288
402
 
289
 
    def __init__(self, revision_id):
 
403
    def __init__(self, revision_id, committer='?', nick=None):
290
404
        self.revision_id = revision_id
291
405
        self.parent_ids = []
292
 
        self.committer = "?"
 
406
        self.committer = committer
293
407
        self.message = "?"
294
408
        self.timestamp = 0.0
295
409
        self.timezone = 0
 
410
        self.properties = {}
 
411
 
 
412
    def get_apparent_author(self):
 
413
        return self.committer
296
414
 
297
415
 
298
416
class RevisionCache(object):
299
417
    """A caching revision source"""
300
 
    def __init__(self, real_source):
 
418
    def __init__(self, real_source, seed_cache=None):
301
419
        self.__real_source = real_source
302
 
        self.__cache = {}
 
420
        if seed_cache is None:
 
421
            self.__cache = {}
 
422
        else:
 
423
            self.__cache = dict(seed_cache)
303
424
 
304
425
    def get_revision(self, revision_id):
305
426
        if revision_id not in self.__cache:
306
427
            revision = self.__real_source.get_revision(revision_id)
307
428
            self.__cache[revision_id] = revision
308
429
        return self.__cache[revision_id]
 
430
 
 
431
class SearchBox(gtk.HBox):
 
432
    """A button box for searching in text or lines of annotations"""
 
433
    def __init__(self):
 
434
        gtk.HBox.__init__(self, False, 6)
 
435
 
 
436
        # Close button
 
437
        button = gtk.Button()
 
438
        image = gtk.Image()
 
439
        image.set_from_stock('gtk-stop', gtk.ICON_SIZE_BUTTON)
 
440
        button.set_image(image)
 
441
        button.set_relief(gtk.RELIEF_NONE)
 
442
        button.connect("clicked", lambda w: self.hide_all())
 
443
        self.pack_start(button, expand=False, fill=False)
 
444
 
 
445
        # Search entry
 
446
        label = gtk.Label()
 
447
        self._label = label
 
448
        self.pack_start(label, expand=False, fill=False)
 
449
 
 
450
        entry = gtk.Entry()
 
451
        self._entry = entry
 
452
        entry.connect("activate", lambda w, d: self._do_search(d),
 
453
                      'forward')
 
454
        self.pack_start(entry, expand=False, fill=False)
 
455
 
 
456
        # Next/previous buttons
 
457
        button = gtk.Button('_Next')
 
458
        image = gtk.Image()
 
459
        image.set_from_stock('gtk-go-forward', gtk.ICON_SIZE_BUTTON)
 
460
        button.set_image(image)
 
461
        button.connect("clicked", lambda w, d: self._do_search(d),
 
462
                       'forward')
 
463
        self.pack_start(button, expand=False, fill=False)
 
464
 
 
465
        button = gtk.Button('_Previous')
 
466
        image = gtk.Image()
 
467
        image.set_from_stock('gtk-go-back', gtk.ICON_SIZE_BUTTON)
 
468
        button.set_image(image)
 
469
        button.connect("clicked", lambda w, d: self._do_search(d),
 
470
                       'backward')
 
471
        self.pack_start(button, expand=False, fill=False)
 
472
 
 
473
        # Search options
 
474
        check = gtk.CheckButton('Match case')
 
475
        self._match_case = check
 
476
        self.pack_start(check, expand=False, fill=False)
 
477
 
 
478
        check = gtk.CheckButton('Regexp')
 
479
        check.connect("toggled", lambda w: self._set_label())
 
480
        self._regexp = check
 
481
        self.pack_start(check, expand=False, fill=False)
 
482
 
 
483
        self._view = None
 
484
        self._column = None
 
485
        # Note that we stay hidden (we do not call self.show_all())
 
486
 
 
487
 
 
488
    def show_for(self, kind):
 
489
        self._kind = kind
 
490
        self.show_all()
 
491
        self._set_label()
 
492
        # Hide unrelated buttons
 
493
        if kind == 'line':
 
494
            self._match_case.hide()
 
495
            self._regexp.hide()
 
496
        # Be ready
 
497
        self._entry.grab_focus()
 
498
 
 
499
    def _set_label(self):
 
500
        if self._kind == 'line':
 
501
            self._label.set_text('Find Line: ')
 
502
        else:
 
503
            if self._regexp.get_active():
 
504
                self._label.set_text('Find Regexp: ')
 
505
            else:
 
506
                self._label.set_text('Find Text: ')
 
507
 
 
508
    def set_target(self, view,column):
 
509
        self._view = view
 
510
        self._column = column
 
511
 
 
512
    def _match(self, model, iterator, column):
 
513
        matching_case = self._match_case.get_active()
 
514
        string, = model.get(iterator, column)
 
515
        key = self._entry.get_text()
 
516
        if self._regexp.get_active():
 
517
            if matching_case:
 
518
                match = re.compile(key).search(string, 1)
 
519
            else:
 
520
                match = re.compile(key, re.I).search(string, 1)
 
521
        else:
 
522
            if not matching_case:
 
523
                string = string.lower()
 
524
                key = key.lower()
 
525
            match = string.find(key) != -1
 
526
 
 
527
        return match
 
528
 
 
529
    def _iterate_rows_forward(self, model, start):
 
530
        model_size = len(model)
 
531
        current = start + 1
 
532
        while model_size != 0:
 
533
            if current >= model_size: current =  0
 
534
            yield model.get_iter_from_string('%d' % current)
 
535
            if current == start: raise StopIteration
 
536
            current += 1
 
537
 
 
538
    def _iterate_rows_backward(self, model, start):
 
539
        model_size = len(model)
 
540
        current = start - 1
 
541
        while model_size != 0:
 
542
            if current < 0: current = model_size - 1
 
543
            yield model.get_iter_from_string('%d' % current)
 
544
            if current == start: raise StopIteration
 
545
            current -= 1
 
546
 
 
547
    def _do_search(self, direction):
 
548
        if direction == 'forward':
 
549
            iterate = self._iterate_rows_forward
 
550
        else:
 
551
            iterate = self._iterate_rows_backward
 
552
 
 
553
        model, sel = self._view.get_selection().get_selected()
 
554
        if sel is None:
 
555
            start = 0
 
556
        else:
 
557
            path = model.get_string_from_iter(sel)
 
558
            start = int(path)
 
559
 
 
560
        for row in iterate(model, start):
 
561
            if self._match(model, row, self._column):
 
562
                path = model.get_path(row)
 
563
                self._view.set_cursor(path)
 
564
                self._view.scroll_to_cell(path, use_align=True)
 
565
                break