/b-gtk/fix-viz : revision 793.1.1

1

#!/usr/bin/python

2

# -*- coding: UTF-8 -*-

3

4

5

#

6

# This program is free software; you can redistribute it and/or modify

7

# it under the terms of the GNU General Public License as published by

8

# the Free Software Foundation; either version 2 of the License, or

9

# (at your option) any later version.

10

#

11

# This program is distributed in the hope that it will be useful,

12

# but WITHOUT ANY WARRANTY; without even the implied warranty of

13

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

14

# GNU General Public License for more details.

15

#

16

# You should have received a copy of the GNU General Public License

17

# along with this program; if not, write to the Free Software

18

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

19

20

import os

21

import sys

22

import time

23

24

# gettext support

25

import gettext

26

gettext.install('olive-gtk')

27

28

try:

29

import pygtk

30

pygtk.require("2.0")

31

except:

32

pass

33

34

import gobject

35

import gtk

36

import gtk.gdk

37

import gtk.glade

38

39

from bzrlib.branch import Branch

40

import bzrlib.errors as bzrerrors

41

from bzrlib.lazy_import import lazy_import

42

from bzrlib.ui import ui_factory

43

from bzrlib.workingtree import WorkingTree

44

45

from bzrlib.plugins.gtk.dialog import error_dialog, info_dialog, warning_dialog

46

from bzrlib.plugins.gtk.errors import show_bzr_error

47

from guifiles import GLADEFILENAME

48

49

from bzrlib.plugins.gtk.diff import DiffWindow

50

lazy_import(globals(), """

51

from bzrlib.plugins.gtk.viz import branchwin

52

""")

53

from bzrlib.plugins.gtk.annotate.gannotate import GAnnotateWindow

54

from bzrlib.plugins.gtk.annotate.config import GAnnotateConfig

55

from bzrlib.plugins.gtk.commit import CommitDialog

56

from bzrlib.plugins.gtk.conflicts import ConflictsDialog

57

from bzrlib.plugins.gtk.initialize import InitDialog

58

from bzrlib.plugins.gtk.push import PushDialog

59

from bzrlib.plugins.gtk.revbrowser import RevisionBrowser

60

61

def about():

62

""" Display the AboutDialog. """

63

from bzrlib.plugins.gtk import __version__

64

from bzrlib.plugins.gtk.olive.guifiles import GLADEFILENAME

65

66

# Load AboutDialog description

67

dglade = gtk.glade.XML(GLADEFILENAME, 'aboutdialog')

68

dialog = dglade.get_widget('aboutdialog')

69

70

# Set version

71

dialog.set_version(__version__)

72

dialog.set_authors([ _("Lead Developer:"),

73

"Szilveszter Farkas <szilveszter.farkas@gmail.com>",

74

_("Contributors:"),

75

"Jelmer Vernooij <jelmer@samba.org>",

76

"Mateusz Korniak <mateusz.korniak@ant.gliwice.pl>",

77

"Gary van der Merwe <garyvdm@gmail.com>" ])

78

dialog.set_artists([ "Simon Pascal Klein <klepas@klepas.org>",

79

"Jakub Steiner <jimmac@novell.com>" ])

80

81

dialog.run()

82

# Destroy the dialog

83

dialog.destroy()

84

85

class OliveGtk:

86

""" The main Olive GTK frontend class. This is called when launching the

87

program. """

88

89

def __init__(self):

90

self.toplevel = gtk.glade.XML(GLADEFILENAME, 'window_main', 'olive-gtk')

91

self.window = self.toplevel.get_widget('window_main')

92

self.pref = Preferences()

93

self.path = None

94

95

# Initialize the statusbar

96

self.statusbar = self.toplevel.get_widget('statusbar')

97

self.context_id = self.statusbar.get_context_id('olive')

98

99

# Get the main window

100

self.window_main = self.toplevel.get_widget('window_main')

101

# Get the HPaned

102

self.hpaned_main = self.toplevel.get_widget('hpaned_main')

103

# Get the TreeViews

104

self.treeview_left = self.toplevel.get_widget('treeview_left')

105

self.treeview_right = self.toplevel.get_widget('treeview_right')

106

# Get some important menu items

107

self.menuitem_add_files = self.toplevel.get_widget('menuitem_add_files')

108

self.menuitem_remove_files = self.toplevel.get_widget('menuitem_remove_file')

109

self.menuitem_file_make_directory = self.toplevel.get_widget('menuitem_file_make_directory')

110

self.menuitem_file_rename = self.toplevel.get_widget('menuitem_file_rename')

111

self.menuitem_file_move = self.toplevel.get_widget('menuitem_file_move')

112

self.menuitem_file_annotate = self.toplevel.get_widget('menuitem_file_annotate')

113

self.menuitem_view_show_hidden_files = self.toplevel.get_widget('menuitem_view_show_hidden_files')

114

self.menuitem_view_show_ignored_files = self.toplevel.get_widget('menuitem_view_show_ignored_files')

115

self.menuitem_branch = self.toplevel.get_widget('menuitem_branch')

116

self.menuitem_branch_init = self.toplevel.get_widget('menuitem_branch_initialize')

117

self.menuitem_branch_get = self.toplevel.get_widget('menuitem_branch_get')

118

self.menuitem_branch_checkout = self.toplevel.get_widget('menuitem_branch_checkout')

119

self.menuitem_branch_pull = self.toplevel.get_widget('menuitem_branch_pull')

120

self.menuitem_branch_push = self.toplevel.get_widget('menuitem_branch_push')

121

self.menuitem_branch_update = self.toplevel.get_widget('menuitem_branch_update')

122

self.menuitem_branch_revert = self.toplevel.get_widget('menuitem_branch_revert')

123

self.menuitem_branch_merge = self.toplevel.get_widget('menuitem_branch_merge')

124

self.menuitem_branch_commit = self.toplevel.get_widget('menuitem_branch_commit')

125

self.menuitem_branch_tags = self.toplevel.get_widget('menuitem_branch_tags')

126

self.menuitem_branch_status = self.toplevel.get_widget('menuitem_branch_status')

127

self.menuitem_branch_missing = self.toplevel.get_widget('menuitem_branch_missing_revisions')

128

self.menuitem_branch_conflicts = self.toplevel.get_widget('menuitem_branch_conflicts')

129

self.menuitem_stats = self.toplevel.get_widget('menuitem_stats')

130

self.menuitem_stats_diff = self.toplevel.get_widget('menuitem_stats_diff')

131

self.menuitem_stats_log = self.toplevel.get_widget('menuitem_stats_log')

132

# Get some toolbuttons

133

#self.menutoolbutton_diff = self.toplevel.get_widget('menutoolbutton_diff')

134

self.toolbutton_diff = self.toplevel.get_widget('toolbutton_diff')

135

self.toolbutton_log = self.toplevel.get_widget('toolbutton_log')

136

self.toolbutton_commit = self.toplevel.get_widget('toolbutton_commit')

137

self.toolbutton_pull = self.toplevel.get_widget('toolbutton_pull')

138

self.toolbutton_push = self.toplevel.get_widget('toolbutton_push')

139

self.toolbutton_update = self.toplevel.get_widget('toolbutton_update')

140

# Get the drive selector

141

self.combobox_drive = gtk.combo_box_new_text()

142

self.combobox_drive.connect("changed", self._refresh_drives)

143

144

# Get the navigation widgets

145

self.hbox_location = self.toplevel.get_widget('hbox_location')

146

self.button_location_up = self.toplevel.get_widget('button_location_up')

147

self.button_location_jump = self.toplevel.get_widget('button_location_jump')

148

self.entry_location = self.toplevel.get_widget('entry_location')

149

self.image_location_error = self.toplevel.get_widget('image_location_error')

150

151

# Get the History widgets

152

self.check_history = self.toplevel.get_widget('checkbutton_history')

153

self.entry_history = self.toplevel.get_widget('entry_history_revno')

154

self.button_history = self.toplevel.get_widget('button_history_browse')

155

156

self.vbox_main_right = self.toplevel.get_widget('vbox_main_right')

157

158

# Dictionary for signal_autoconnect

159

dic = { "on_window_main_destroy": gtk.main_quit,

160

"on_window_main_delete_event": self.on_window_main_delete_event,

161

"on_quit_activate": self.on_window_main_delete_event,

162

"on_about_activate": self.on_about_activate,

163

"on_menuitem_add_files_activate": self.on_menuitem_add_files_activate,

164

"on_menuitem_remove_file_activate": self.on_menuitem_remove_file_activate,

165

"on_menuitem_file_make_directory_activate": self.on_menuitem_file_make_directory_activate,

166

"on_menuitem_file_move_activate": self.on_menuitem_file_move_activate,

167

"on_menuitem_file_rename_activate": self.on_menuitem_file_rename_activate,

168

"on_menuitem_file_annotate_activate": self.on_menuitem_file_annotate_activate,

169

"on_menuitem_view_show_hidden_files_activate": self.on_menuitem_view_show_hidden_files_activate,

170

"on_menuitem_view_show_ignored_files_activate": self.on_menuitem_view_show_ignored_files_activate,

171

"on_menuitem_view_refresh_activate": self.on_menuitem_view_refresh_activate,

172

"on_menuitem_branch_initialize_activate": self.on_menuitem_branch_initialize_activate,

173

"on_menuitem_branch_get_activate": self.on_menuitem_branch_get_activate,

174

"on_menuitem_branch_checkout_activate": self.on_menuitem_branch_checkout_activate,

175

"on_menuitem_branch_revert_activate": self.on_menuitem_branch_revert_activate,

176

"on_menuitem_branch_merge_activate": self.on_menuitem_branch_merge_activate,

177

"on_menuitem_branch_commit_activate": self.on_menuitem_branch_commit_activate,

178

"on_menuitem_branch_push_activate": self.on_menuitem_branch_push_activate,

179

"on_menuitem_branch_pull_activate": self.on_menuitem_branch_pull_activate,

180

"on_menuitem_branch_update_activate": self.on_menuitem_branch_update_activate,

181

"on_menuitem_branch_tags_activate": self.on_menuitem_branch_tags_activate,

182

"on_menuitem_branch_status_activate": self.on_menuitem_branch_status_activate,

183

"on_menuitem_branch_missing_revisions_activate": self.on_menuitem_branch_missing_revisions_activate,

184

"on_menuitem_branch_conflicts_activate": self.on_menuitem_branch_conflicts_activate,

185

"on_menuitem_stats_diff_activate": self.on_menuitem_stats_diff_activate,

186

"on_menuitem_stats_log_activate": self.on_menuitem_stats_log_activate,

187

"on_menuitem_stats_infos_activate": self.on_menuitem_stats_infos_activate,

188

"on_toolbutton_refresh_clicked": self.on_menuitem_view_refresh_activate,

189

"on_toolbutton_log_clicked": self.on_menuitem_stats_log_activate,

190

#"on_menutoolbutton_diff_clicked": self.on_menuitem_stats_diff_activate,

191

"on_toolbutton_diff_clicked": self.on_menuitem_stats_diff_activate,

192

"on_toolbutton_commit_clicked": self.on_menuitem_branch_commit_activate,

193

"on_toolbutton_pull_clicked": self.on_menuitem_branch_pull_activate,

194

"on_toolbutton_push_clicked": self.on_menuitem_branch_push_activate,

195

"on_toolbutton_update_clicked": self.on_menuitem_branch_update_activate,

196

"on_treeview_right_button_press_event": self.on_treeview_right_button_press_event,

197

"on_treeview_right_row_activated": self.on_treeview_right_row_activated,

198

"on_treeview_left_button_press_event": self.on_treeview_left_button_press_event,

199

"on_treeview_left_row_activated": self.on_treeview_left_row_activated,

200

"on_button_location_up_clicked": self.on_button_location_up_clicked,

201

"on_button_location_jump_clicked": self.on_button_location_jump_clicked,

202

"on_entry_location_key_press_event": self.on_entry_location_key_press_event,

203

"on_checkbutton_history_toggled": self.on_checkbutton_history_toggled,

204

"on_entry_history_revno_key_press_event": self.on_entry_history_revno_key_press_event,

205

"on_button_history_browse_clicked": self.on_button_history_browse_clicked

206

}

207

208

# Connect the signals to the handlers

209

self.toplevel.signal_autoconnect(dic)

210

211

self._just_started = True

212

213

# Apply window size and position

214

width = self.pref.get_preference('window_width', 'int')

215

height = self.pref.get_preference('window_height', 'int')

216

self.window.resize(width, height)

217

x = self.pref.get_preference('window_x', 'int')

218

y = self.pref.get_preference('window_y', 'int')

219

self.window.move(x, y)

220

# Apply paned position

221

pos = self.pref.get_preference('paned_position', 'int')

222

self.hpaned_main.set_position(pos)

223

224

# Apply menu to the toolbutton

225

#menubutton = self.toplevel.get_widget('menutoolbutton_diff')

226

#menubutton.set_menu(handler.menu.toolbar_diff)

227

228

# Now we can show the window

229

self.window.show()

230

231

# Show drive selector if under Win32

232

if sys.platform == 'win32':

233

self.hbox_location.pack_start(self.combobox_drive, False, False, 0)

234

self.hbox_location.reorder_child(self.combobox_drive, 1)

235

self.combobox_drive.show()

236

self.gen_hard_selector()

237

238

self._load_left()

239

240

# Apply menu state

241

self.menuitem_view_show_hidden_files.set_active(self.pref.get_preference('dotted_files', 'bool'))

242

self.menuitem_view_show_ignored_files.set_active(self.pref.get_preference('ignored_files', 'bool'))

243

244

# We're starting local

245

self.remote = False

246

self.remote_branch = None

247

self.remote_path = None

248

self.remote_revision = None

249

250

self.set_path(os.getcwd())

251

self._load_right()

252

253

self._just_started = False

254

255

def set_path(self, path, force_remote=False):

256

self.notbranch = False

257

258

if force_remote:

259

# Forcing remote mode (reading data from inventory)

260

self._show_stock_image(gtk.STOCK_DISCONNECT)

261

try:

262

br = Branch.open_containing(path)[0]

263

except bzrerrors.NotBranchError:

264

self._show_stock_image(gtk.STOCK_DIALOG_ERROR)

265

self.check_history.set_active(False)

266

self.check_history.set_sensitive(False)

267

return False

268

except bzrerrors.UnsupportedProtocol:

269

self._show_stock_image(gtk.STOCK_DIALOG_ERROR)

270

self.check_history.set_active(False)

271

self.check_history.set_sensitive(False)

272

return False

273

274

self._show_stock_image(gtk.STOCK_CONNECT)

275

276

self.remote = True

277

278

# We're remote

279

self.remote_branch, self.remote_path = Branch.open_containing(path)

280

281

if self.remote_revision is None:

282

self.remote_revision = self.remote_branch.last_revision()

283

284

self.remote_entries = self.remote_branch.repository.get_inventory(self.remote_revision).entries()

285

286

if len(self.remote_path) == 0:

287

self.remote_parent = self.remote_branch.repository.get_inventory(self.remote_branch.last_revision()).iter_entries_by_dir().next()[1].file_id

288

else:

289

for (name, type) in self.remote_entries:

290

if name == self.remote_path:

291

self.remote_parent = type.file_id

292

break

293

294

if not path.endswith('/'):

295

path += '/'

296

297

if self.remote_branch.base == path:

298

self.button_location_up.set_sensitive(False)

299

else:

300

self.button_location_up.set_sensitive(True)

301

else:

302

if os.path.isdir(path):

303

self.image_location_error.destroy()

304

self.remote = False

305

306

# We're local

307

try:

308

self.wt, self.wtpath = WorkingTree.open_containing(path)

309

except (bzrerrors.NotBranchError, bzrerrors.NoWorkingTree):

310

self.notbranch = True

311

312

# If we're in the root, we cannot go up anymore

313

if sys.platform == 'win32':

314

drive, tail = os.path.splitdrive(path)

315

if tail in ('', '/', '\\'):

316

self.button_location_up.set_sensitive(False)

317

else:

318

self.button_location_up.set_sensitive(True)

319

else:

320

if self.path == '/':

321

self.button_location_up.set_sensitive(False)

322

else:

323

self.button_location_up.set_sensitive(True)

324

elif not os.path.isfile(path):

325

# Doesn't seem to be a file nor a directory, trying to open a

326

# remote location

327

self._show_stock_image(gtk.STOCK_DISCONNECT)

328

try:

329

br = Branch.open_containing(path)[0]

330

except bzrerrors.NotBranchError:

331

self._show_stock_image(gtk.STOCK_DIALOG_ERROR)

332

self.check_history.set_active(False)

333

self.check_history.set_sensitive(False)

334

return False

335

except bzrerrors.UnsupportedProtocol:

336

self._show_stock_image(gtk.STOCK_DIALOG_ERROR)

337

self.check_history.set_active(False)

338

self.check_history.set_sensitive(False)

339

return False

340

341

self._show_stock_image(gtk.STOCK_CONNECT)

342

343

self.remote = True

344

345

# We're remote

346

self.remote_branch, self.remote_path = Branch.open_containing(path)

347

348

if self.remote_revision is None:

349

self.remote_revision = self.remote_branch.last_revision()

350

351

self.remote_entries = self.remote_branch.repository.get_inventory(self.remote_revision).entries()

352

353

if len(self.remote_path) == 0:

354

self.remote_parent = self.remote_branch.repository.get_inventory(self.remote_branch.last_revision()).iter_entries_by_dir().next()[1].file_id

355

else:

356

for (name, type) in self.remote_entries:

357

if name == self.remote_path:

358

self.remote_parent = type.file_id

359

break

360

361

if not path.endswith('/'):

362

path += '/'

363

364

if self.remote_branch.base == path:

365

self.button_location_up.set_sensitive(False)

366

else:

367

self.button_location_up.set_sensitive(True)

368

369

if self.notbranch:

370

self.check_history.set_active(False)

371

self.check_history.set_sensitive(False)

372

else:

373

self.check_history.set_sensitive(True)

374

375

self.statusbar.push(self.context_id, path)

376

self.entry_location.set_text(path)

377

self.path = path

378

return True

379

380

def get_path(self):

381

if not self.remote:

382

return self.path

383

else:

384

# Remote mode

385

if len(self.remote_path) > 0:

386

return self.remote_branch.base + self.remote_path + '/'

387

else:

388

return self.remote_branch.base

389

390

def on_about_activate(self, widget):

391

about()

392

393

def on_button_history_browse_clicked(self, widget):

394

""" Browse for revision button handler. """

395

if self.remote:

396

br = self.remote_branch

397

else:

398

br = self.wt.branch

399

400

revb = RevisionBrowser(br, self.window)

401

response = revb.run()

402

if response != gtk.RESPONSE_NONE:

403

revb.hide()

404

405

if response == gtk.RESPONSE_OK:

406

if revb.selected_revno is not None:

407

self.entry_history.set_text(revb.selected_revno)

408

409

revb.destroy()

410

411

def on_button_location_jump_clicked(self, widget):

412

""" Location Jump button handler. """

413

location = self.entry_location.get_text()

414

415

if self.set_path(location):

416

self.refresh_right()

417

418

def on_button_location_up_clicked(self, widget):

419

""" Location Up button handler. """

420

if not self.remote:

421

# Local mode

422

self.set_path(os.path.split(self.get_path())[0])

423

else:

424

# Remote mode

425

delim = '/'

426

newpath = delim.join(self.get_path().split(delim)[:-2])

427

newpath += '/'

428

self.set_path(newpath)

429

430

self.refresh_right()

431

432

def on_checkbutton_history_toggled(self, widget):

433

""" History Mode toggle handler. """

434

if self.check_history.get_active():

435

# History Mode activated

436

self.entry_history.set_sensitive(True)

437

self.button_history.set_sensitive(True)

438

else:

439

# History Mode deactivated

440

self.entry_history.set_sensitive(False)

441

self.button_history.set_sensitive(False)

442

443

@show_bzr_error

444

def on_entry_history_revno_key_press_event(self, widget, event):

445

""" Key pressed handler for the history entry. """

446

if event.keyval == 65293:

447

# Return was hit, so we have to load that specific revision

448

# Emulate being remote, so inventory should be used

449

path = self.get_path()

450

if not self.remote:

451

self.remote = True

452

self.remote_branch = self.wt.branch

453

454

revno = int(self.entry_history.get_text())

455

self.remote_revision = self.remote_branch.get_rev_id(revno)

456

if self.set_path(path, True):

457

self.refresh_right()

458

459

def on_entry_location_key_press_event(self, widget, event):

460

""" Key pressed handler for the location entry. """

461

if event.keyval == 65293:

462

# Return was hit, so we have to jump

463

self.on_button_location_jump_clicked(widget)

464

465

def on_menuitem_add_files_activate(self, widget):

466

""" Add file(s)... menu handler. """

467

from add import OliveAdd

468

add = OliveAdd(self.wt, self.wtpath, self.get_selected_right())

469

add.display()

470

471

def on_menuitem_branch_get_activate(self, widget):

472

""" Branch/Get... menu handler. """

473

from bzrlib.plugins.gtk.branch import BranchDialog

474

475

if self.remote:

476

branch = BranchDialog(os.getcwd(), self.window, self.remote_branch.base)

477

else:

478

branch = BranchDialog(self.get_path(), self.window)

479

response = branch.run()

480

if response != gtk.RESPONSE_NONE:

481

branch.hide()

482

483

if response == gtk.RESPONSE_OK:

484

self.refresh_right()

485

486

branch.destroy()

487

488

def on_menuitem_branch_checkout_activate(self, widget):

489

""" Branch/Checkout... menu handler. """

490

from bzrlib.plugins.gtk.checkout import CheckoutDialog

491

492

if self.remote:

493

checkout = CheckoutDialog(os.getcwd(), self.window, self.remote_branch.base)

494

else:

495

checkout = CheckoutDialog(self.get_path(), self.window)

496

response = checkout.run()

497

if response != gtk.RESPONSE_NONE:

498

checkout.hide()

499

500

if response == gtk.RESPONSE_OK:

501

self.refresh_right()

502

503

checkout.destroy()

504

505

@show_bzr_error

506

def on_menuitem_branch_commit_activate(self, widget):

507

""" Branch/Commit... menu handler. """

508

# def __init__(self, wt, wtpath, notbranch, selected=None, parent=None):

509

selected = self.get_selected_right()

510

if selected:

511

selected = os.path.join(self.wtpath, selected)

512

commit = CommitDialog(wt=self.wt,

513

parent=self.window,

514

selected=selected,

515

)

516

response = commit.run()

517

if response != gtk.RESPONSE_NONE:

518

commit.hide()

519

520

if response == gtk.RESPONSE_OK:

521

self.refresh_right()

522

523

commit.destroy()

524

525

def on_menuitem_branch_conflicts_activate(self, widget):

526

""" Branch/Conflicts... menu handler. """

527

conflicts = ConflictsDialog(self.wt, self.window)

528

response = conflicts.run()

529

if response != gtk.RESPONSE_NONE:

530

conflicts.destroy()

531

532

def on_menuitem_branch_merge_activate(self, widget):

533

""" Branch/Merge... menu handler. """

534

from bzrlib.plugins.gtk.merge import MergeDialog

535

536

if self.check_for_changes():

537

error_dialog(_('There are local changes in the branch'),

538

_('Please commit or revert the changes before merging.'))

539

else:

540

parent_branch_path = self.wt.branch.get_parent()

541

merge = MergeDialog(self.wt, self.wtpath,default_branch_path=parent_branch_path )

542

merge.display()

543

544

@show_bzr_error

545

def on_menuitem_branch_missing_revisions_activate(self, widget):

546

""" Branch/Missing revisions menu handler. """

547

548

from bzrlib.missing import find_unmerged, iter_log_revisions

549

550

local_branch = self.wt.branch

551

parent_branch_path = local_branch.get_parent()

552

if parent_branch_path is None:

553

error_dialog(_('Parent location is unknown'),

554

_('Cannot determine missing revisions if no parent location is known.'))

555

return

556

557

parent_branch = Branch.open(parent_branch_path)

558

559

if parent_branch.base == local_branch.base:

560

parent_branch = local_branch

561

562

local_extra, remote_extra = find_unmerged(local_branch,parent_branch)

563

564

if local_extra or remote_extra:

565

566

## def log_revision_one_line_text(log_revision):

567

## """ Generates one line description of log_revison ended with end of line."""

568

## revision = log_revision.rev

569

## txt = "- %s (%s)\n" % (revision.get_summary(), revision.committer, )

570

## txt = txt.replace("<"," ") # Seems < > chars are expected to be xml tags ...

571

## txt = txt.replace(">"," ")

572

## return txt

573

574

dlg_txt = ""

575

if local_extra:

576

dlg_txt += _('%d local extra revision(s). \n') % (len(local_extra),)

577

## NOTE: We do not want such ugly info about missing revisions

578

## Revision Browser should be used there

579

## max_revisions = 10

580

## for log_revision in iter_log_revisions(local_extra, local_branch.repository, verbose=1):

581

## dlg_txt += log_revision_one_line_text(log_revision)

582

## if max_revisions <= 0:

583

## dlg_txt += _("more ... \n")

584

## break

585

## max_revisions -= 1

586

## dlg_txt += "\n"

587

if remote_extra:

588

dlg_txt += _('%d local missing revision(s).\n') % (len(remote_extra),)

589

## max_revisions = 10

590

## for log_revision in iter_log_revisions(remote_extra, parent_branch.repository, verbose=1):

591

## dlg_txt += log_revision_one_line_text(log_revision)

592

## if max_revisions <= 0:

593

## dlg_txt += _("more ... \n")

594

## break

595

## max_revisions -= 1

596

597

info_dialog(_('There are missing revisions'),

598

dlg_txt)

599

else:

600

info_dialog(_('Local branch up to date'),

601

_('There are no missing revisions.'))

602

603

@show_bzr_error

604

def on_menuitem_branch_pull_activate(self, widget):

605

""" Branch/Pull menu handler. """

606

branch_to = self.wt.branch

607

608

location = branch_to.get_parent()

609

if location is None:

610

error_dialog(_('Parent location is unknown'),

611

_('Pulling is not possible until there is a parent location.'))

612

return

613

614

branch_from = Branch.open(location)

615

616

if branch_to.get_parent() is None:

617

branch_to.set_parent(branch_from.base)

618

619

ret = branch_to.pull(branch_from)

620

621

info_dialog(_('Pull successful'), _('%d revision(s) pulled.') % ret)

622

623

@show_bzr_error

624

def on_menuitem_branch_update_activate(self, widget):

625

""" Brranch/checkout update menu handler. """

626

627

ret = self.wt.update()

628

conflicts = self.wt.conflicts()

629

if conflicts:

630

info_dialog(_('Update successful but conflicts generated'), _('Number of conflicts generated: %d.') % (len(conflicts),) )

631

else:

632

info_dialog(_('Update successful'), _('No conflicts generated.') )

633

634

def on_menuitem_branch_push_activate(self, widget):

635

""" Branch/Push... menu handler. """

636

push = PushDialog(repository=None,revid=None,branch=self.wt.branch, parent=self.window)

637

response = push.run()

638

if response != gtk.RESPONSE_NONE:

639

push.destroy()

640

641

@show_bzr_error

642

def on_menuitem_branch_revert_activate(self, widget):

643

""" Branch/Revert all changes menu handler. """

644

ret = self.wt.revert([])

645

if ret:

646

warning_dialog(_('Conflicts detected'),

647

_('Please have a look at the working tree before continuing.'))

648

else:

649

info_dialog(_('Revert successful'),

650

_('All files reverted to last revision.'))

651

self.refresh_right()

652

653

def on_menuitem_branch_status_activate(self, widget):

654

""" Branch/Status... menu handler. """

655

from bzrlib.plugins.gtk.status import StatusDialog

656

status = StatusDialog(self.wt, self.wtpath)

657

response = status.run()

658

if response != gtk.RESPONSE_NONE:

659

status.destroy()

660

661

def on_menuitem_branch_initialize_activate(self, widget):

662

""" Initialize current directory. """

663

init = InitDialog(self.path, self.window)

664

response = init.run()

665

if response != gtk.RESPONSE_NONE:

666

init.hide()

667

668

if response == gtk.RESPONSE_OK:

669

self.refresh_right()

670

671

init.destroy()

672

673

def on_menuitem_branch_tags_activate(self, widget):

674

""" Branch/Tags... menu handler. """

675

from bzrlib.plugins.gtk.tags import TagsWindow

676

if not self.remote:

677

window = TagsWindow(self.wt.branch, self.window)

678

else:

679

window = TagsWindow(self.remote_branch, self.window)

680

window.show()

681

682

def on_menuitem_file_annotate_activate(self, widget):

683

""" File/Annotate... menu handler. """

684

if self.get_selected_right() is None:

685

error_dialog(_('No file was selected'),

686

_('Please select a file from the list.'))

687

return

688

689

branch = self.wt.branch

690

file_id = self.wt.path2id(self.wt.relpath(os.path.join(self.path, self.get_selected_right())))

691

692

window = GAnnotateWindow(all=False, plain=False, parent=self.window)

693

window.set_title(os.path.join(self.path, self.get_selected_right()) + " - Annotate")

694

config = GAnnotateConfig(window)

695

window.show()

696

branch.lock_read()

697

try:

698

window.annotate(self.wt, branch, file_id)

699

finally:

700

branch.unlock()

701

702

def on_menuitem_file_make_directory_activate(self, widget):

703

""" File/Make directory... menu handler. """

704

from mkdir import OliveMkdir

705

mkdir = OliveMkdir(self.wt, self.wtpath)

706

mkdir.display()

707

708

def on_menuitem_file_move_activate(self, widget):

709

""" File/Move... menu handler. """

710

from move import OliveMove

711

move = OliveMove(self.wt, self.wtpath, self.get_selected_right())

712

move.display()

713

714

def on_menuitem_file_rename_activate(self, widget):

715

""" File/Rename... menu handler. """

716

from rename import OliveRename

717

rename = OliveRename(self.wt, self.wtpath, self.get_selected_right())

718

rename.display()

719

720

def on_menuitem_remove_file_activate(self, widget):

721

""" Remove (unversion) selected file. """

722

from remove import OliveRemoveDialog

723

remove = OliveRemoveDialog(self.wt, self.wtpath,

724

selected=self.get_selected_right(),

725

parent=self.window)

726

response = remove.run()

727

728

if response != gtk.RESPONSE_NONE:

729

remove.hide()

730

731

if response == gtk.RESPONSE_OK:

732

self.set_path(self.path)

733

self.refresh_right()

734

735

remove.destroy()

736

737

def on_menuitem_stats_diff_activate(self, widget):

738

""" Statistics/Differences... menu handler. """

739

window = DiffWindow(parent=self.window)

740

parent_tree = self.wt.branch.repository.revision_tree(self.wt.branch.last_revision())

741

window.set_diff(self.wt.branch.nick, self.wt, parent_tree)

742

window.show()

743

744

def on_menuitem_stats_infos_activate(self, widget):

745

""" Statistics/Informations... menu handler. """

746

from info import OliveInfo

747

if self.remote:

748

info = OliveInfo(self.remote_branch)

749

else:

750

info = OliveInfo(self.wt.branch)

751

info.display()

752

753

def on_menuitem_stats_log_activate(self, widget):

754

""" Statistics/Log... menu handler. """

755

756

if not self.remote:

757

branch = self.wt.branch

758

else:

759

branch = self.remote_branch

760

761

window = branchwin.BranchWindow(branch, branch.last_revision(), None, parent=self.window)

762

window.show()

763

764

def on_menuitem_view_refresh_activate(self, widget):

765

""" View/Refresh menu handler. """

766

# Refresh the left pane

767

self.refresh_left()

768

# Refresh the right pane

769

self.refresh_right()

770

771

def on_menuitem_view_show_hidden_files_activate(self, widget):

772

""" View/Show hidden files menu handler. """

773

self.pref.set_preference('dotted_files', widget.get_active())

774

if self.path is not None:

775

self.refresh_right()

776

777

def on_menuitem_view_show_ignored_files_activate(self, widget):

778

""" Hide/Show ignored files menu handler. """

779

self.pref.set_preference('ignored_files', widget.get_active())

780

if self.path is not None:

781

self.refresh_right()

782

783

def on_treeview_left_button_press_event(self, widget, event):

784

""" Occurs when somebody right-clicks in the bookmark list. """

785

if event.button == 3:

786

# Don't show context with nothing selected

787

if self.get_selected_left() == None:

788

return

789

790

# Create a menu

791

from menu import OliveMenu

792

menu = OliveMenu(path=self.get_path(),

793

selected=self.get_selected_left(),

794

app=self)

795

796

menu.left_context_menu().popup(None, None, None, 0,

797

event.time)

798

799

def on_treeview_left_row_activated(self, treeview, path, view_column):

800

""" Occurs when somebody double-clicks or enters an item in the

801

bookmark list. """

802

803

newdir = self.get_selected_left()

804

if newdir == None:

805

return

806

807

if self.set_path(newdir):

808

self.refresh_right()

809

810

def on_treeview_right_button_press_event(self, widget, event):

811

""" Occurs when somebody right-clicks in the file list. """

812

if event.button == 3:

813

# Create a menu

814

from menu import OliveMenu

815

menu = OliveMenu(path=self.get_path(),

816

selected=self.get_selected_right(),

817

app=self)

818

# get the menu items

819

m_open = menu.ui.get_widget('/context_right/open')

820

m_add = menu.ui.get_widget('/context_right/add')

821

m_remove = menu.ui.get_widget('/context_right/remove')

822

m_rename = menu.ui.get_widget('/context_right/rename')

823

m_revert = menu.ui.get_widget('/context_right/revert')

824

m_commit = menu.ui.get_widget('/context_right/commit')

825

m_annotate = menu.ui.get_widget('/context_right/annotate')

826

m_diff = menu.ui.get_widget('/context_right/diff')

827

# check if we're in a branch

828

try:

829

from bzrlib.branch import Branch

830

Branch.open_containing(self.get_path())

831

if self.remote:

832

m_open.set_sensitive(False)

833

m_add.set_sensitive(False)

834

m_remove.set_sensitive(False)

835

m_rename.set_sensitive(False)

836

m_revert.set_sensitive(False)

837

m_commit.set_sensitive(False)

838

m_annotate.set_sensitive(False)

839

m_diff.set_sensitive(False)

840

else:

841

m_open.set_sensitive(True)

842

m_add.set_sensitive(True)

843

m_remove.set_sensitive(True)

844

m_rename.set_sensitive(True)

845

m_revert.set_sensitive(True)

846

m_commit.set_sensitive(True)

847

m_annotate.set_sensitive(True)

848

m_diff.set_sensitive(True)

849

except bzrerrors.NotBranchError:

850

m_open.set_sensitive(True)

851

m_add.set_sensitive(False)

852

m_remove.set_sensitive(False)

853

m_rename.set_sensitive(False)

854

m_revert.set_sensitive(False)

855

m_commit.set_sensitive(False)

856

m_annotate.set_sensitive(False)

857

m_diff.set_sensitive(False)

858

859

if not self.remote:

860

menu.right_context_menu().popup(None, None, None, 0,

861

event.time)

862

else:

863

menu.remote_context_menu().popup(None, None, None, 0,

864

event.time)

865

866

def on_treeview_right_row_activated(self, treeview, path, view_column):

867

""" Occurs when somebody double-clicks or enters an item in the

868

file list. """

869

from launch import launch

870

871

newdir = self.get_selected_right()

872

873

if not self.remote:

874

# We're local

875

if newdir == '..':

876

self.set_path(os.path.split(self.get_path())[0])

877

else:

878

fullpath = os.path.join(self.get_path(), newdir)

879

if os.path.isdir(fullpath):

880

# selected item is an existant directory

881

self.set_path(fullpath)

882

else:

883

launch(fullpath)

884

else:

885

# We're remote

886

if self._is_remote_dir(self.get_path() + newdir):

887

self.set_path(self.get_path() + newdir)

888

889

self.refresh_right()

890

891

def on_window_main_delete_event(self, widget, event=None):

892

""" Do some stuff before exiting. """

893

width, height = self.window_main.get_size()

894

self.pref.set_preference('window_width', width)

895

self.pref.set_preference('window_height', height)

896

x, y = self.window_main.get_position()

897

self.pref.set_preference('window_x', x)

898

self.pref.set_preference('window_y', y)

899

self.pref.set_preference('paned_position',

900

self.hpaned_main.get_position())

901

902

self.pref.write()

903

self.window_main.destroy()

904

905

def _load_left(self):

906

""" Load data into the left panel. (Bookmarks) """

907

# Create TreeStore

908

treestore = gtk.TreeStore(str, str)

909

910

# Get bookmarks

911

bookmarks = self.pref.get_bookmarks()

912

913

# Add them to the TreeStore

914

titer = treestore.append(None, [_('Bookmarks'), None])

915

for item in bookmarks:

916

title = self.pref.get_bookmark_title(item)

917

treestore.append(titer, [title, item])

918

919

# Create the column and add it to the TreeView

920

self.treeview_left.set_model(treestore)

921

tvcolumn_bookmark = gtk.TreeViewColumn(_('Bookmark'))

922

self.treeview_left.append_column(tvcolumn_bookmark)

923

924

# Set up the cells

925

cell = gtk.CellRendererText()

926

tvcolumn_bookmark.pack_start(cell, True)

927

tvcolumn_bookmark.add_attribute(cell, 'text', 0)

928

929

# Expand the tree

930

self.treeview_left.expand_all()

931

932

def _load_right(self):

933

""" Load data into the right panel. (Filelist) """

934

# Create ListStore

935

# Model: [ icon, dir, name, status text, status, size (int), size (human), mtime (int), mtime (local), fileid ]

936

liststore = gtk.ListStore(gobject.TYPE_STRING,

937

gobject.TYPE_BOOLEAN,

938

gobject.TYPE_STRING,

939

gobject.TYPE_STRING,

940

gobject.TYPE_STRING,

941

gobject.TYPE_STRING,

942

gobject.TYPE_STRING,

943

gobject.TYPE_INT,

944

gobject.TYPE_STRING,

945

gobject.TYPE_STRING)

946

947

dirs = []

948

files = []

949

950

# Fill the appropriate lists

951

dotted_files = self.pref.get_preference('dotted_files', 'bool')

952

for item in os.listdir(self.path):

953

if not dotted_files and item[0] == '.':

954

continue

955

if os.path.isdir(self.path + os.sep + item):

956

dirs.append(item)

957

else:

958

files.append(item)

959

960

if not self.notbranch:

961

branch = self.wt.branch

962

tree2 = self.wt.branch.repository.revision_tree(branch.last_revision())

963

964

delta = self.wt.changes_from(tree2, want_unchanged=True)

965

966

# Add'em to the ListStore

967

for item in dirs:

968

try:

969

statinfo = os.stat(self.path + os.sep + item)

970

except OSError, e:

971

if e.errno == 40:

972

continue

973

else:

974

raise

975

liststore.append([ gtk.STOCK_DIRECTORY,

976

True,

977

item,

978

'',

979

'',

980

"<DIR>",

981

"<DIR>",

982

statinfo.st_mtime,

983

self._format_date(statinfo.st_mtime),

984

''])

985

for item in files:

986

status = 'unknown'

987

fileid = ''

988

if not self.notbranch:

989

filename = self.wt.relpath(self.path + os.sep + item)

990

991

try:

992

self.wt.lock_read()

993

994

for rpath, rpathnew, id, kind, text_modified, meta_modified in delta.renamed:

995

if rpathnew == filename:

996

status = 'renamed'

997

fileid = id

998

for rpath, id, kind in delta.added:

999

if rpath == filename:

1000

status = 'added'

1001

fileid = id

1002

for rpath, id, kind in delta.removed:

1003

if rpath == filename:

1004

status = 'removed'

1005

fileid = id

1006

for rpath, id, kind, text_modified, meta_modified in delta.modified:

1007

if rpath == filename:

1008

status = 'modified'

1009

fileid = id

1010

for rpath, id, kind in delta.unchanged:

1011

if rpath == filename:

1012

status = 'unchanged'

1013

fileid = id

1014

for rpath, file_class, kind, id, entry in self.wt.list_files():

1015

if rpath == filename and file_class == 'I':

1016

status = 'ignored'

1017

finally:

1018

self.wt.unlock()

1019

1020

if status == 'renamed':

1021

st = _('renamed')

1022

elif status == 'removed':

1023

st = _('removed')

1024

elif status == 'added':

1025

st = _('added')

1026

elif status == 'modified':

1027

st = _('modified')

1028

elif status == 'unchanged':

1029

st = _('unchanged')

1030

elif status == 'ignored':

1031

st = _('ignored')

1032

else:

1033

st = _('unknown')

1034

1035

try:

1036

statinfo = os.stat(self.path + os.sep + item)

1037

except OSError, e:

1038

if e.errno == 40:

1039

continue

1040

else:

1041

raise

1042

liststore.append([gtk.STOCK_FILE,

1043

False,

1044

item,

1045

st,

1046

status,

1047

str(statinfo.st_size), # NOTE: if int used there it will fail for large files (size expressed as long int)

1048

self._format_size(statinfo.st_size),

1049

statinfo.st_mtime,

1050

self._format_date(statinfo.st_mtime),

1051

fileid])

1052

1053

# Create the columns and add them to the TreeView

1054

self.treeview_right.set_model(liststore)

1055

self._tvcolumn_filename = gtk.TreeViewColumn(_('Filename'))

1056

self._tvcolumn_status = gtk.TreeViewColumn(_('Status'))

1057

self._tvcolumn_size = gtk.TreeViewColumn(_('Size'))

1058

self._tvcolumn_mtime = gtk.TreeViewColumn(_('Last modified'))

1059

self.treeview_right.append_column(self._tvcolumn_filename)

1060

self.treeview_right.append_column(self._tvcolumn_status)

1061

self.treeview_right.append_column(self._tvcolumn_size)

1062

self.treeview_right.append_column(self._tvcolumn_mtime)

1063

1064

# Set up the cells

1065

cellpb = gtk.CellRendererPixbuf()

1066

cell = gtk.CellRendererText()

1067

self._tvcolumn_filename.pack_start(cellpb, False)

1068

self._tvcolumn_filename.pack_start(cell, True)

1069

self._tvcolumn_filename.set_attributes(cellpb, stock_id=0)

1070

self._tvcolumn_filename.add_attribute(cell, 'text', 2)

1071

self._tvcolumn_status.pack_start(cell, True)

1072

self._tvcolumn_status.add_attribute(cell, 'text', 3)

1073

self._tvcolumn_size.pack_start(cell, True)

1074

self._tvcolumn_size.add_attribute(cell, 'text', 6)

1075

self._tvcolumn_mtime.pack_start(cell, True)

1076

self._tvcolumn_mtime.add_attribute(cell, 'text', 8)

1077

1078

# Set up the properties of the TreeView

1079

self.treeview_right.set_headers_visible(True)

1080

self.treeview_right.set_headers_clickable(True)

1081

self.treeview_right.set_search_column(1)

1082

self._tvcolumn_filename.set_resizable(True)

1083

self._tvcolumn_status.set_resizable(True)

1084

self._tvcolumn_size.set_resizable(True)

1085

self._tvcolumn_mtime.set_resizable(True)

1086

# Set up sorting

1087

liststore.set_sort_func(13, self._sort_filelist_callback, None)

1088

liststore.set_sort_column_id(13, gtk.SORT_ASCENDING)

1089

self._tvcolumn_filename.set_sort_column_id(13)

1090

self._tvcolumn_status.set_sort_column_id(3)

1091

self._tvcolumn_size.set_sort_column_id(5)

1092

self._tvcolumn_mtime.set_sort_column_id(7)

1093

1094

# Set sensitivity

1095

self.set_sensitivity()

1096

1097

def get_selected_fileid(self):

1098

""" Get the file_id of the selected file. """

1099

treeselection = self.treeview_right.get_selection()

1100

(model, iter) = treeselection.get_selected()

1101

1102

if iter is None:

1103

return None

1104

else:

1105

return model.get_value(iter, 9)

1106

1107

def get_selected_right(self):

1108

""" Get the selected filename. """

1109

treeselection = self.treeview_right.get_selection()

1110

(model, iter) = treeselection.get_selected()

1111

1112

if iter is None:

1113

return None

1114

else:

1115

return model.get_value(iter, 2)

1116

1117

def get_selected_left(self):

1118

""" Get the selected bookmark. """

1119

treeselection = self.treeview_left.get_selection()

1120

(model, iter) = treeselection.get_selected()

1121

1122

if iter is None:

1123

return None

1124

else:

1125

return model.get_value(iter, 1)

1126

1127

def set_statusbar(self, message):

1128

""" Set the statusbar message. """

1129

self.statusbar.push(self.context_id, message)

1130

1131

def clear_statusbar(self):

1132

""" Clean the last message from the statusbar. """

1133

self.statusbar.pop(self.context_id)

1134

1135

def set_sensitivity(self):

1136

""" Set menu and toolbar sensitivity. """

1137

if not self.remote:

1138

# We're local

1139

self.menuitem_branch_init.set_sensitive(self.notbranch)

1140

self.menuitem_branch_get.set_sensitive(self.notbranch)

1141

self.menuitem_branch_checkout.set_sensitive(self.notbranch)

1142

self.menuitem_branch_pull.set_sensitive(not self.notbranch)

1143

self.menuitem_branch_push.set_sensitive(not self.notbranch)

1144

self.menuitem_branch_update.set_sensitive(not self.notbranch)

1145

self.menuitem_branch_revert.set_sensitive(not self.notbranch)

1146

self.menuitem_branch_merge.set_sensitive(not self.notbranch)

1147

self.menuitem_branch_commit.set_sensitive(not self.notbranch)

1148

self.menuitem_branch_tags.set_sensitive(not self.notbranch)

1149

self.menuitem_branch_status.set_sensitive(not self.notbranch)

1150

self.menuitem_branch_missing.set_sensitive(not self.notbranch)

1151

self.menuitem_branch_conflicts.set_sensitive(not self.notbranch)

1152

self.menuitem_stats.set_sensitive(not self.notbranch)

1153

self.menuitem_stats_diff.set_sensitive(not self.notbranch)

1154

self.menuitem_add_files.set_sensitive(not self.notbranch)

1155

self.menuitem_remove_files.set_sensitive(not self.notbranch)

1156

self.menuitem_file_make_directory.set_sensitive(not self.notbranch)

1157

self.menuitem_file_rename.set_sensitive(not self.notbranch)

1158

self.menuitem_file_move.set_sensitive(not self.notbranch)

1159

self.menuitem_file_annotate.set_sensitive(not self.notbranch)

1160

#self.menutoolbutton_diff.set_sensitive(True)

1161

self.toolbutton_diff.set_sensitive(not self.notbranch)

1162

self.toolbutton_log.set_sensitive(not self.notbranch)

1163

self.toolbutton_commit.set_sensitive(not self.notbranch)

1164

self.toolbutton_pull.set_sensitive(not self.notbranch)

1165

self.toolbutton_push.set_sensitive(not self.notbranch)

1166

self.toolbutton_update.set_sensitive(not self.notbranch)

1167

else:

1168

# We're remote

1169

self.menuitem_branch_init.set_sensitive(False)

1170

self.menuitem_branch_get.set_sensitive(True)

1171

self.menuitem_branch_checkout.set_sensitive(True)

1172

self.menuitem_branch_pull.set_sensitive(False)

1173

self.menuitem_branch_push.set_sensitive(False)

1174

self.menuitem_branch_update.set_sensitive(False)

1175

self.menuitem_branch_revert.set_sensitive(False)

1176

self.menuitem_branch_merge.set_sensitive(False)

1177

self.menuitem_branch_commit.set_sensitive(False)

1178

self.menuitem_branch_tags.set_sensitive(True)

1179

self.menuitem_branch_status.set_sensitive(False)

1180

self.menuitem_branch_missing.set_sensitive(False)

1181

self.menuitem_branch_conflicts.set_sensitive(False)

1182

self.menuitem_stats.set_sensitive(True)

1183

self.menuitem_stats_diff.set_sensitive(False)

1184

self.menuitem_add_files.set_sensitive(False)

1185

self.menuitem_remove_files.set_sensitive(False)

1186

self.menuitem_file_make_directory.set_sensitive(False)

1187

self.menuitem_file_rename.set_sensitive(False)

1188

self.menuitem_file_move.set_sensitive(False)

1189

self.menuitem_file_annotate.set_sensitive(False)

1190

#self.menutoolbutton_diff.set_sensitive(True)

1191

self.toolbutton_diff.set_sensitive(False)

1192

self.toolbutton_log.set_sensitive(True)

1193

self.toolbutton_commit.set_sensitive(False)

1194

self.toolbutton_pull.set_sensitive(False)

1195

self.toolbutton_push.set_sensitive(False)

1196

self.toolbutton_update.set_sensitive(False)

1197

1198

def refresh_left(self):

1199

""" Refresh the bookmark list. """

1200

1201

# Get TreeStore and clear it

1202

treestore = self.treeview_left.get_model()

1203

treestore.clear()

1204

1205

# Re-read preferences

1206

self.pref.read()

1207

1208

# Get bookmarks

1209

bookmarks = self.pref.get_bookmarks()

1210

1211

# Add them to the TreeStore

1212

titer = treestore.append(None, [_('Bookmarks'), None])

1213

for item in bookmarks:

1214

title = self.pref.get_bookmark_title(item)

1215

treestore.append(titer, [title, item])

1216

1217

# Add the TreeStore to the TreeView

1218

self.treeview_left.set_model(treestore)

1219

1220

# Expand the tree

1221

self.treeview_left.expand_all()

1222

1223

def refresh_right(self, path=None):

1224

""" Refresh the file list. """

1225

if not self.remote:

1226

# We're local

1227

from bzrlib.workingtree import WorkingTree

1228

1229

if path is None:

1230

path = self.get_path()

1231

1232

# A workaround for double-clicking Bookmarks

1233

if not os.path.exists(path):

1234

return

1235

1236

# Get ListStore and clear it

1237

liststore = self.treeview_right.get_model()

1238

liststore.clear()

1239

1240

# Show Status column

1241

self._tvcolumn_status.set_visible(True)

1242

1243

dirs = []

1244

files = []

1245

1246

# Fill the appropriate lists

1247

dotted_files = self.pref.get_preference('dotted_files', 'bool')

1248

ignored_files = self.pref.get_preference('ignored_files', 'bool')

1249

1250

for item in os.listdir(path):

1251

if not dotted_files and item[0] == '.':

1252

continue

1253

if os.path.isdir(path + os.sep + item):

1254

dirs.append(item)

1255

else:

1256

files.append(item)

1257

1258

# Try to open the working tree

1259

notbranch = False

1260

try:

1261

tree1 = WorkingTree.open_containing(path)[0]

1262

except (bzrerrors.NotBranchError, bzrerrors.NoWorkingTree):

1263

notbranch = True

1264

1265

if not notbranch:

1266

branch = tree1.branch

1267

tree2 = tree1.branch.repository.revision_tree(branch.last_revision())

1268

1269

delta = tree1.changes_from(tree2, want_unchanged=True)

1270

1271

# Add'em to the ListStore

1272

for item in dirs:

1273

try:

1274

statinfo = os.stat(self.path + os.sep + item)

1275

except OSError, e:

1276

if e.errno == 40:

1277

continue

1278

else:

1279

raise

1280

liststore.append([gtk.STOCK_DIRECTORY,

1281

True,

1282

item,

1283

'',

1284

'',

1285

"<DIR>",

1286

"<DIR>",

1287

statinfo.st_mtime,

1288

self._format_date(statinfo.st_mtime),

1289

''])

1290

for item in files:

1291

status = 'unknown'

1292

fileid = ''

1293

if not notbranch:

1294

filename = tree1.relpath(path + os.sep + item)

1295

1296

try:

1297

self.wt.lock_read()

1298

1299

for rpath, rpathnew, id, kind, text_modified, meta_modified in delta.renamed:

1300

if rpathnew == filename:

1301

status = 'renamed'

1302

fileid = id

1303

for rpath, id, kind in delta.added:

1304

if rpath == filename:

1305

status = 'added'

1306

fileid = id

1307

for rpath, id, kind in delta.removed:

1308

if rpath == filename:

1309

status = 'removed'

1310

fileid = id

1311

for rpath, id, kind, text_modified, meta_modified in delta.modified:

1312

if rpath == filename:

1313

status = 'modified'

1314

fileid = id

1315

for rpath, id, kind in delta.unchanged:

1316

if rpath == filename:

1317

status = 'unchanged'

1318

fileid = id

1319

for rpath, file_class, kind, id, entry in self.wt.list_files():

1320

if rpath == filename and file_class == 'I':

1321

status = 'ignored'

1322

finally:

1323

self.wt.unlock()

1324

1325

if status == 'renamed':

1326

st = _('renamed')

1327

elif status == 'removed':

1328

st = _('removed')

1329

elif status == 'added':

1330

st = _('added')

1331

elif status == 'modified':

1332

st = _('modified')

1333

elif status == 'unchanged':

1334

st = _('unchanged')

1335

elif status == 'ignored':

1336

st = _('ignored')

1337

if not ignored_files:

1338

continue

1339

else:

1340

st = _('unknown')

1341

1342

try:

1343

statinfo = os.stat(self.path + os.sep + item)

1344

except OSError, e:

1345

if e.errno == 40:

1346

continue

1347

else:

1348

raise

1349

liststore.append([gtk.STOCK_FILE,

1350

False,

1351

item,

1352

st,

1353

status,

1354

str(statinfo.st_size),

1355

self._format_size(statinfo.st_size),

1356

statinfo.st_mtime,

1357

self._format_date(statinfo.st_mtime),

1358

fileid])

1359

else:

1360

# We're remote

1361

1362

# Get ListStore and clear it

1363

liststore = self.treeview_right.get_model()

1364

liststore.clear()

1365

1366

# Hide Status column

1367

self._tvcolumn_status.set_visible(False)

1368

1369

dirs = []

1370

files = []

1371

1372

self._show_stock_image(gtk.STOCK_REFRESH)

1373

1374

for (name, type) in self.remote_entries:

1375

if type.kind == 'directory':

1376

dirs.append(type)

1377

elif type.kind == 'file':

1378

files.append(type)

1379

1380

class HistoryCache:

1381

""" Cache based on revision history. """

1382

def __init__(self, history):

1383

self._history = history

1384

1385

def _lookup_revision(self, revid):

1386

for r in self._history:

1387

if r.revision_id == revid:

1388

return r

1389

rev = repo.get_revision(revid)

1390

self._history.append(rev)

1391

return rev

1392

1393

repo = self.remote_branch.repository

1394

1395

revhistory = self.remote_branch.revision_history()

1396

try:

1397

revs = repo.get_revisions(revhistory)

1398

cache = HistoryCache(revs)

1399

except bzrerrors.InvalidHttpResponse:

1400

# Fallback to dummy algorithm, because of LP: #115209

1401

cache = HistoryCache([])

1402

1403

for item in dirs:

1404

if item.parent_id == self.remote_parent:

1405

rev = cache._lookup_revision(item.revision)

1406

liststore.append([ gtk.STOCK_DIRECTORY,

1407

True,

1408

item.name,

1409

'',

1410

'',

1411

"<DIR>",

1412

"<DIR>",

1413

rev.timestamp,

1414

self._format_date(rev.timestamp),

1415

''

1416

])

1417

while gtk.events_pending():

1418

gtk.main_iteration()

1419

1420

for item in files:

1421

if item.parent_id == self.remote_parent:

1422

rev = cache._lookup_revision(item.revision)

1423

liststore.append([ gtk.STOCK_FILE,

1424

False,

1425

item.name,

1426

'',

1427

'',

1428

str(item.text_size),

1429

self._format_size(item.text_size),

1430

rev.timestamp,

1431

self._format_date(rev.timestamp),

1432

item.file_id

1433

])

1434

while gtk.events_pending():

1435

gtk.main_iteration()

1436

1437

self.image_location_error.destroy()

1438

1439

# Columns should auto-size

1440

self.treeview_right.columns_autosize()

1441

1442

# Set sensitivity

1443

self.set_sensitivity()

1444

1445

def _harddisks(self):

1446

""" Returns hard drive letters under Win32. """

1447

try:

1448

import win32file

1449

import string

1450

except ImportError:

1451

if sys.platform == 'win32':

1452

print "pyWin32 modules needed to run Olive on Win32."

1453

sys.exit(1)

1454

else:

1455

pass

1456

1457

driveletters = []

1458

for drive in string.ascii_uppercase:

1459

if win32file.GetDriveType(drive+':') == win32file.DRIVE_FIXED:

1460

driveletters.append(drive+':')

1461

return driveletters

1462

1463

def gen_hard_selector(self):

1464

""" Generate the hard drive selector under Win32. """

1465

drives = self._harddisks()

1466

for drive in drives:

1467

self.combobox_drive.append_text(drive)

1468

self.combobox_drive.set_active(drives.index(os.getcwd()[0:2]))

1469

1470

def _refresh_drives(self, combobox):

1471

if self._just_started:

1472

return

1473

model = combobox.get_model()

1474

active = combobox.get_active()

1475

if active >= 0:

1476

drive = model[active][0]

1477

self.set_path(drive + '\\')

1478

self.refresh_right(drive + '\\')

1479

1480

def check_for_changes(self):

1481

""" Check whether there were changes in the current working tree. """

1482

old_tree = self.wt.branch.repository.revision_tree(self.wt.branch.last_revision())

1483

delta = self.wt.changes_from(old_tree)

1484

1485

changes = False

1486

1487

if len(delta.added) or len(delta.removed) or len(delta.renamed) or len(delta.modified):

1488

changes = True

1489

1490

return changes

1491

1492

def _sort_filelist_callback(self, model, iter1, iter2, data):

1493

""" The sort callback for the file list, return values:

1494

-1: iter1 < iter2

1495

0: iter1 = iter2

1496

1: iter1 > iter2

1497

"""

1498

name1 = model.get_value(iter1, 2)

1499

name2 = model.get_value(iter2, 2)

1500

1501

if model.get_value(iter1, 1):

1502

# item1 is a directory

1503

if not model.get_value(iter2, 1):

1504

# item2 isn't

1505

return -1

1506

else:

1507

# both of them are directories, we compare their names

1508

if name1 < name2:

1509

return -1

1510

elif name1 == name2:

1511

return 0

1512

else:

1513

return 1

1514

else:

1515

# item1 is not a directory

1516

if model.get_value(iter2, 1):

1517

# item2 is

1518

return 1

1519

else:

1520

# both of them are files, compare them

1521

if name1 < name2:

1522

return -1

1523

elif name1 == name2:

1524

return 0

1525

else:

1526

return 1

1527

1528

def _format_size(self, size):

1529

""" Format size to a human readable format. """

1530

if size < 1000:

1531

return "%d[B]" % (size,)

1532

size = size / 1000.0

1533

1534

for metric in ["kB","MB","GB","TB"]:

1535

if size < 1000:

1536

break

1537

size = size / 1000.0

1538

return "%.1f[%s]" % (size,metric)

1539

1540

def _format_date(self, timestamp):

1541

""" Format the time (given in secs) to a human readable format. """

1542

return time.ctime(timestamp)

1543

1544

def _is_remote_dir(self, location):

1545

""" Determine whether the given location is a directory or not. """

1546

if not self.remote:

1547

# We're in local mode

1548

return False

1549

else:

1550

branch, path = Branch.open_containing(location)

1551

for (name, type) in self.remote_entries:

1552

if name == path and type.kind == 'directory':

1553

# We got it

1554

return True

1555

# Either it's not a directory or not in the inventory

1556

return False

1557

1558

def _show_stock_image(self, stock_id):

1559

""" Show a stock image next to the location entry. """

1560

self.image_location_error.destroy()

1561

self.image_location_error = gtk.image_new_from_stock(stock_id, gtk.ICON_SIZE_BUTTON)

1562

self.hbox_location.pack_start(self.image_location_error, False, False, 0)

1563

if sys.platform == 'win32':

1564

self.hbox_location.reorder_child(self.image_location_error, 2)

1565

else:

1566

self.hbox_location.reorder_child(self.image_location_error, 1)

1567

self.image_location_error.show()

1568

while gtk.events_pending():

1569

gtk.main_iteration()

1570

1571

import ConfigParser

1572

1573

class Preferences:

1574

""" A class which handles Olive's preferences. """

1575

def __init__(self, path=None):

1576

""" Initialize the Preferences class. """

1577

# Some default options

1578

self.defaults = { 'strict_commit' : False,

1579

'dotted_files' : False,

1580

'ignored_files' : True,

1581

'window_width' : 700,

1582

'window_height' : 400,

1583

'window_x' : 40,

1584

'window_y' : 40,

1585

'paned_position': 200 }

1586

1587

# Create a config parser object

1588

self.config = ConfigParser.RawConfigParser()

1589

1590

# Set filename

1591

if path is None:

1592

if sys.platform == 'win32':

1593

# Windows - no dotted files

1594

self._filename = os.path.expanduser('~/olive.conf')

1595

else:

1596

self._filename = os.path.expanduser('~/.olive.conf')

1597

else:

1598

self._filename = path

1599

1600

# Load the configuration

1601

self.read()

1602

1603

def _get_default(self, option):

1604

""" Get the default option for a preference. """

1605

try:

1606

ret = self.defaults[option]

1607

except KeyError:

1608

return None

1609

else:

1610

return ret

1611

1612

def refresh(self):

1613

""" Refresh the configuration. """

1614

# First write out the changes

1615

self.write()

1616

# Then load the configuration again

1617

self.read()

1618

1619

def read(self):

1620

""" Just read the configuration. """

1621

# Re-initialize the config parser object to avoid some bugs

1622

self.config = ConfigParser.RawConfigParser()

1623

self.config.read([self._filename])

1624

1625

def write(self):

1626

""" Write the configuration to the appropriate files. """

1627

fp = open(self._filename, 'w')

1628

self.config.write(fp)

1629

fp.close()

1630

1631

def get_bookmarks(self):

1632

""" Return the list of bookmarks. """

1633

bookmarks = self.config.sections()

1634

if self.config.has_section('preferences'):

1635

bookmarks.remove('preferences')

1636

return bookmarks

1637

1638

def add_bookmark(self, path):

1639

""" Add bookmark. """

1640

try:

1641

self.config.add_section(path)

1642

except ConfigParser.DuplicateSectionError:

1643

return False

1644

else:

1645

return True

1646

1647

def get_bookmark_title(self, path):

1648

""" Get bookmark title. """

1649

try:

1650

ret = self.config.get(path, 'title')

1651

except ConfigParser.NoOptionError:

1652

ret = path

1653

1654

return ret

1655

1656

def set_bookmark_title(self, path, title):

1657

""" Set bookmark title. """

1658

# FIXME: What if path isn't listed yet?

1659

# FIXME: Canonicalize paths first?

1660

self.config.set(path, 'title', title)

1661

1662

def remove_bookmark(self, path):

1663

""" Remove bookmark. """

1664

return self.config.remove_section(path)

1665

1666

def set_preference(self, option, value):

1667

""" Set the value of the given option. """

1668

if value is True:

1669

value = 'yes'

1670

elif value is False:

1671

value = 'no'

1672

1673

if self.config.has_section('preferences'):

1674

self.config.set('preferences', option, value)

1675

else:

1676

self.config.add_section('preferences')

1677

self.config.set('preferences', option, value)

1678

1679

def get_preference(self, option, kind='str'):

1680

""" Get the value of the given option.

1681

1682

:param kind: str/bool/int/float. default: str

1683

"""

1684

if self.config.has_option('preferences', option):

1685

if kind == 'bool':

1686

return self.config.getboolean('preferences', option)

1687

elif kind == 'int':

1688

return self.config.getint('preferences', option)

1689

elif kind == 'float':

1690

return self.config.getfloat('preferences', option)

1691

else:

1692

return self.config.get('preferences', option)

1693

else:

1694

try:

1695

return self._get_default(option)

1696

except KeyError:

1697

return None

1698