/b-gtk/fix-viz : revision 597.1.1

1

2

#

3

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

4

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

5

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

6

# (at your option) any later version.

7

#

8

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

9

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

10

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11

# GNU General Public License for more details.

12

#

13

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

14

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

15

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

16

17

import os

18

import sys

19

import time

20

import errno

21

22

# gettext support

23

import gettext

24

gettext.install('olive-gtk')

25

26

try:

27

import pygtk

28

pygtk.require("2.0")

29

except:

30

pass

31

32

import gobject

33

import gtk

34

import gtk.gdk

35

36

from bzrlib.branch import Branch

37

import bzrlib.errors as bzrerrors

38

from bzrlib.lazy_import import lazy_import

39

from bzrlib.ui import ui_factory

40

from bzrlib.workingtree import WorkingTree

41

42

from bzrlib.plugins.gtk import _i18n

43

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

44

from bzrlib.plugins.gtk.errors import show_bzr_error

45

from bzrlib.plugins.gtk.olive.window import OliveGui

46

47

from bzrlib.plugins.gtk.diff import DiffWindow

48

lazy_import(globals(), """

49

from bzrlib.plugins.gtk.viz import branchwin

50

""")

51

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

52

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

53

from bzrlib.plugins.gtk.commit import CommitDialog

54

from bzrlib.plugins.gtk.conflicts import ConflictsDialog

55

from bzrlib.plugins.gtk.initialize import InitDialog

56

from bzrlib.plugins.gtk.push import PushDialog

57

from bzrlib.plugins.gtk.revbrowser import RevisionBrowser

58

59

def about():

60

""" Display the AboutDialog. """

61

from bzrlib.plugins.gtk import __version__, icon_path

62

63

iconpath = icon_path() + os.sep

64

65

dialog = gtk.AboutDialog()

66

dialog.set_name("Olive")

67

dialog.set_version(__version__)

68

69

dialog.set_website("https://launchpad.net/products/olive")

70

dialog.set_website_label("https://launchpad.net/products/olive")

71

dialog.set_icon_from_file(iconpath+"oliveicon2.png")

72

dialog.set_logo(gtk.gdk.pixbuf_new_from_file(iconpath+"oliveicon2.png"))

73

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

74

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

75

_i18n("Contributors:"),

76

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

77

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

78

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

79

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

80

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

81

82

dialog.run()

83

# Destroy the dialog

84

dialog.destroy()

85

86

class OliveGtk:

87

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

88

program. """

89

90

def __init__(self):

91

self.window = OliveGui(calling_app = self)

92

93

self.pref = Preferences()

94

self.path = None

95

96

# Initialize the statusbar

97

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

98

99

# Get the drive selector

100

self.combobox_drive = gtk.combo_box_new_text()

101

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

102

103

# Get the navigation widgets

104

self.hbox_location = self.window.locationbar

105

self.button_location_up = self.window.button_location_up

106

self.button_location_jump = self.window.button_location_jump

107

self.entry_location = self.window.entry_location

108

109

# Get the History widgets

110

self.check_history = self.window.checkbutton_history

111

self.entry_history = self.window.entry_history_revno

112

self.button_history = self.window.button_history_browse

113

114

self._just_started = True

115

116

# Apply window size and position

117

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

118

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

119

self.window.resize(width, height)

120

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

121

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

122

self.window.move(x, y)

123

# Apply paned position

124

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

125

self.window.hpaned_main.set_position(pos)

126

127

# Now we can show the window

128

self.window.show()

129

130

# Show drive selector if under Win32

131

if sys.platform == 'win32':

132

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

133

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

134

self.combobox_drive.show()

135

self.gen_hard_selector()

136

137

# Acceptable errors when loading files/folders in the treeviews

138

self.acceptable_errors = (errno.ENOENT, errno.ELOOP)

139

140

self.refresh_left()

141

142

# Apply menu state

143

self.window.mb_view_showhidden.set_active(self.pref.get_preference('dotted_files', 'bool'))

144

self.window.mb_view_showignored.set_active(self.pref.get_preference('ignored_files', 'bool'))

145

146

# We're starting local

147

self.remote = False

148

self.remote_branch = None

149

self.remote_path = None

150

self.remote_revision = None

151

152

self.set_path(os.getcwd())

153

self.refresh_right()

154

155

self._just_started = False

156

157

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

158

self.window.location_status.destroy()

159

self.notbranch = False

160

161

if force_remote:

162

# Forcing remote mode (reading data from inventory)

163

self.window.set_location_status(gtk.STOCK_DISCONNECT)

164

try:

165

br = Branch.open_containing(path)[0]

166

except bzrerrors.NotBranchError:

167

self.window.set_location_status(gtk.STOCK_DIALOG_ERROR)

168

self.check_history.set_active(False)

169

self.check_history.set_sensitive(False)

170

return False

171

except bzrerrors.UnsupportedProtocol:

172

self.window.set_location_status(gtk.STOCK_DIALOG_ERROR)

173

self.check_history.set_active(False)

174

self.check_history.set_sensitive(False)

175

return False

176

177

self.window.set_location_status(gtk.STOCK_CONNECT)

178

179

self.remote = True

180

181

# We're remote

182

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

183

184

if self.remote_revision is None:

185

self.remote_revision = self.remote_branch.last_revision()

186

187

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

188

189

if len(self.remote_path) == 0:

190

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

191

else:

192

for (name, type) in self.remote_entries:

193

if name == self.remote_path:

194

self.remote_parent = type.file_id

195

break

196

197

if not path.endswith('/'):

198

path += '/'

199

200

if self.remote_branch.base == path:

201

self.button_location_up.set_sensitive(False)

202

else:

203

self.button_location_up.set_sensitive(True)

204

else:

205

if os.path.isdir(path):

206

self.remote = False

207

208

# We're local

209

try:

210

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

211

except (bzrerrors.NotBranchError, bzrerrors.NoWorkingTree):

212

self.notbranch = True

213

except bzrerrors.PermissionDenied:

214

self.window.set_location_status(gtk.STOCK_DIALOG_WARNING, allowPopup=True)

215

self.window.location_status.connect_object('clicked', warning_dialog,

216

*(_i18n('Branch information unreadable'),

217

_i18n('The current folder is a branch but the .bzr folder is not readable')))

218

self.notbranch = True

219

220

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

221

if sys.platform == 'win32':

222

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

223

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

224

self.button_location_up.set_sensitive(False)

225

else:

226

self.button_location_up.set_sensitive(True)

227

else:

228

if self.path == '/':

229

self.button_location_up.set_sensitive(False)

230

else:

231

self.button_location_up.set_sensitive(True)

232

elif not os.path.isfile(path):

233

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

234

# remote location

235

self.window.set_location_status(gtk.STOCK_DISCONNECT)

236

try:

237

br = Branch.open_containing(path)[0]

238

except bzrerrors.NotBranchError:

239

self.window.set_location_status(gtk.STOCK_DIALOG_ERROR)

240

self.check_history.set_active(False)

241

self.check_history.set_sensitive(False)

242

return False

243

except bzrerrors.UnsupportedProtocol:

244

self.window.set_location_status(gtk.STOCK_DIALOG_ERROR)

245

self.check_history.set_active(False)

246

self.check_history.set_sensitive(False)

247

return False

248

249

self.window.set_location_status(gtk.STOCK_CONNECT)

250

251

self.remote = True

252

253

# We're remote

254

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

255

256

if self.remote_revision is None:

257

self.remote_revision = self.remote_branch.last_revision()

258

259

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

260

261

if len(self.remote_path) == 0:

262

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

263

else:

264

for (name, type) in self.remote_entries:

265

if name == self.remote_path:

266

self.remote_parent = type.file_id

267

break

268

269

if not path.endswith('/'):

270

path += '/'

271

272

if self.remote_branch.base == path:

273

self.button_location_up.set_sensitive(False)

274

else:

275

self.button_location_up.set_sensitive(True)

276

277

if self.notbranch:

278

self.check_history.set_active(False)

279

self.check_history.set_sensitive(False)

280

else:

281

self.check_history.set_sensitive(True)

282

283

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

284

self.entry_location.set_text(path)

285

self.path = path

286

return True

287

288

def get_path(self):

289

if not self.remote:

290

return self.path

291

else:

292

# Remote mode

293

if len(self.remote_path) > 0:

294

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

295

else:

296

return self.remote_branch.base

297

298

def on_about_activate(self, widget):

299

about()

300

301

def on_button_history_browse_clicked(self, widget):

302

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

303

if self.remote:

304

br = self.remote_branch

305

else:

306

br = self.wt.branch

307

308

revb = RevisionBrowser(br, self.window)

309

response = revb.run()

310

if response != gtk.RESPONSE_NONE:

311

revb.hide()

312

313

if response == gtk.RESPONSE_OK:

314

if revb.selected_revno is not None:

315

self.entry_history.set_text(revb.selected_revno)

316

self.on_entry_history_revno_activate()

317

318

revb.destroy()

319

320

def on_button_location_jump_clicked(self, widget):

321

""" Location Jump button handler. """

322

location = self.entry_location.get_text()

323

324

if self.set_path(location):

325

self.refresh_right()

326

327

def on_button_location_up_clicked(self, widget):

328

""" Location Up button handler. """

329

if not self.remote:

330

# Local mode

331

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

332

else:

333

# Remote mode

334

delim = '/'

335

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

336

newpath += '/'

337

self.set_path(newpath)

338

339

self.refresh_right()

340

341

def on_checkbutton_history_toggled(self, widget):

342

""" History Mode toggle handler. """

343

if self.check_history.get_active():

344

# History Mode activated

345

self.entry_history.set_sensitive(True)

346

self.button_history.set_sensitive(True)

347

if self.entry_history.get_text() != "":

348

self.on_entry_history_revno_activate()

349

else:

350

# History Mode deactivated

351

self.entry_history.set_sensitive(False)

352

self.button_history.set_sensitive(False)

353

354

# Return right window to normal view by acting like we jump to it

355

self.on_button_location_jump_clicked(widget)

356

357

@show_bzr_error

358

def on_entry_history_revno_activate(self, widget=None):

359

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

360

path = self.get_path()

361

if not self.remote:

362

self.remote = True

363

self.remote_branch = self.wt.branch

364

365

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

366

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

367

if self.set_path(path, True):

368

self.refresh_right()

369

370

def on_menuitem_add_files_activate(self, widget):

371

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

372

from bzrlib.plugins.gtk.olive.add import AddDialog

373

add = AddDialog(self.wt, self.wtpath, self.get_selected_right(), self.window)

374

response = add.run()

375

add.destroy()

376

if response == gtk.RESPONSE_OK:

377

self.refresh_right()

378

379

def on_menuitem_branch_get_activate(self, widget):

380

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

381

from bzrlib.plugins.gtk.branch import BranchDialog

382

383

if self.remote:

384

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

385

else:

386

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

387

response = branch.run()

388

if response != gtk.RESPONSE_NONE:

389

branch.hide()

390

391

if response == gtk.RESPONSE_OK:

392

self.refresh_right()

393

394

branch.destroy()

395

396

def on_menuitem_branch_checkout_activate(self, widget):

397

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

398

from bzrlib.plugins.gtk.checkout import CheckoutDialog

399

400

if self.remote:

401

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

402

else:

403

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

404

response = checkout.run()

405

if response != gtk.RESPONSE_NONE:

406

checkout.hide()

407

408

if response == gtk.RESPONSE_OK:

409

self.refresh_right()

410

411

checkout.destroy()

412

413

@show_bzr_error

414

def on_menuitem_branch_commit_activate(self, widget):

415

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

416

selected = self.get_selected_right()

417

if selected:

418

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

419

commit = CommitDialog(wt=self.wt,

420

parent=self.window,

421

selected=selected,

422

)

423

response = commit.run()

424

if response != gtk.RESPONSE_NONE:

425

commit.hide()

426

427

if response == gtk.RESPONSE_OK:

428

self.refresh_right()

429

430

commit.destroy()

431

432

def on_menuitem_branch_conflicts_activate(self, widget):

433

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

434

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

435

response = conflicts.run()

436

if response != gtk.RESPONSE_NONE:

437

conflicts.destroy()

438

439

def on_menuitem_branch_merge_activate(self, widget):

440

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

441

from bzrlib.plugins.gtk.merge import MergeDialog

442

443

if self.check_for_changes():

444

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

445

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

446

else:

447

parent_branch_path = self.wt.branch.get_parent()

448

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

449

response = merge.run()

450

merge.destroy()

451

if response == gtk.RESPONSE_OK:

452

self.refresh_right()

453

454

@show_bzr_error

455

def on_menuitem_branch_missing_revisions_activate(self, widget):

456

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

457

458

from bzrlib.missing import find_unmerged, iter_log_revisions

459

460

local_branch = self.wt.branch

461

parent_branch_path = local_branch.get_parent()

462

if parent_branch_path is None:

463

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

464

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

465

return

466

467

parent_branch = Branch.open(parent_branch_path)

468

469

if parent_branch.base == local_branch.base:

470

parent_branch = local_branch

471

472

local_extra, remote_extra = find_unmerged(local_branch,parent_branch)

473

474

if local_extra or remote_extra:

475

476

## def log_revision_one_line_text(log_revision):

477

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

478

## revision = log_revision.rev

479

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

480

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

481

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

482

## return txt

483

484

dlg_txt = ""

485

if local_extra:

486

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

487

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

488

## Revision Browser should be used there

489

## max_revisions = 10

490

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

491

## dlg_txt += log_revision_one_line_text(log_revision)

492

## if max_revisions <= 0:

493

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

494

## break

495

## max_revisions -= 1

496

## dlg_txt += "\n"

497

if remote_extra:

498

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

499

## max_revisions = 10

500

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

501

## dlg_txt += log_revision_one_line_text(log_revision)

502

## if max_revisions <= 0:

503

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

504

## break

505

## max_revisions -= 1

506

507

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

508

dlg_txt)

509

else:

510

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

511

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

512

513

@show_bzr_error

514

def on_menuitem_branch_pull_activate(self, widget):

515

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

516

branch_to = self.wt.branch

517

518

location = branch_to.get_parent()

519

if location is None:

520

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

521

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

522

return

523

524

branch_from = Branch.open(location)

525

526

if branch_to.get_parent() is None:

527

branch_to.set_parent(branch_from.base)

528

529

ret = branch_to.pull(branch_from)

530

531

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

532

533

@show_bzr_error

534

def on_menuitem_branch_update_activate(self, widget):

535

""" Branch/checkout update menu handler. """

536

537

ret = self.wt.update()

538

conflicts = self.wt.conflicts()

539

if conflicts:

540

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

541

else:

542

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

543

self.refresh_right()

544

545

def on_menuitem_branch_push_activate(self, widget):

546

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

547

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

548

response = push.run()

549

if response != gtk.RESPONSE_NONE:

550

push.destroy()

551

552

@show_bzr_error

553

def on_menuitem_branch_revert_activate(self, widget):

554

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

555

ret = self.wt.revert(None)

556

if ret:

557

warning_dialog(_i18n('Conflicts detected'),

558

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

559

else:

560

info_dialog(_i18n('Revert successful'),

561

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

562

self.refresh_right()

563

564

def on_menuitem_branch_status_activate(self, widget):

565

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

566

from bzrlib.plugins.gtk.status import StatusDialog

567

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

568

response = status.run()

569

if response != gtk.RESPONSE_NONE:

570

status.destroy()

571

572

def on_menuitem_branch_initialize_activate(self, widget):

573

""" Initialize current directory. """

574

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

575

response = init.run()

576

if response != gtk.RESPONSE_NONE:

577

init.hide()

578

579

if response == gtk.RESPONSE_OK:

580

self.refresh_right()

581

582

init.destroy()

583

584

def on_menuitem_branch_tags_activate(self, widget):

585

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

586

from bzrlib.plugins.gtk.tags import TagsWindow

587

if not self.remote:

588

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

589

else:

590

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

591

window.show()

592

593

def on_menuitem_file_annotate_activate(self, widget):

594

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

595

if self.get_selected_right() is None:

596

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

597

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

598

return

599

600

branch = self.wt.branch

601

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

602

603

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

604

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

605

config = GAnnotateConfig(window)

606

window.show()

607

branch.lock_read()

608

try:

609

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

610

finally:

611

branch.unlock()

612

613

def on_menuitem_file_bookmark_activate(self, widget):

614

""" File/Bookmark current directory menu handler. """

615

if self.pref.add_bookmark(self.path):

616

info_dialog(_i18n('Bookmark successfully added'),

617

_i18n('The current directory was bookmarked. You can reach\nit by selecting it from the left panel.'))

618

self.pref.write()

619

else:

620

warning_dialog(_i18n('Location already bookmarked'),

621

_i18n('The current directory is already bookmarked.\nSee the left panel for reference.'))

622

623

self.refresh_left()

624

625

def on_menuitem_file_make_directory_activate(self, widget):

626

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

627

from bzrlib.plugins.gtk.olive.mkdir import MkdirDialog

628

mkdir = MkdirDialog(self.wt, self.wtpath, self.window)

629

response = mkdir.run()

630

mkdir.destroy()

631

if response == gtk.RESPONSE_OK:

632

self.refresh_right()

633

634

def on_menuitem_file_move_activate(self, widget):

635

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

636

from bzrlib.plugins.gtk.olive.move import MoveDialog

637

move = MoveDialog(self.wt, self.wtpath, self.get_selected_right(), self.window)

638

response = move.run()

639

move.destroy()

640

if response == gtk.RESPONSE_OK:

641

self.refresh_right()

642

643

def on_menuitem_file_rename_activate(self, widget):

644

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

645

from bzrlib.plugins.gtk.olive.rename import RenameDialog

646

rename = RenameDialog(self.wt, self.wtpath, self.get_selected_right(), self.window)

647

response = rename.run()

648

rename.destroy()

649

if response == gtk.RESPONSE_OK:

650

self.refresh_right()

651

652

def on_menuitem_remove_file_activate(self, widget):

653

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

654

from bzrlib.plugins.gtk.olive.remove import RemoveDialog

655

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

656

selected=self.get_selected_right(),

657

parent=self.window)

658

response = remove.run()

659

660

if response != gtk.RESPONSE_NONE:

661

remove.hide()

662

663

if response == gtk.RESPONSE_OK:

664

self.set_path(self.path)

665

self.refresh_right()

666

667

remove.destroy()

668

669

def on_menuitem_stats_diff_activate(self, widget):

670

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

671

window = DiffWindow(parent=self.window)

672

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

673

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

674

window.show()

675

676

def on_menuitem_stats_infos_activate(self, widget):

677

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

678

from bzrlib.plugins.gtk.olive.info import InfoDialog

679

if self.remote:

680

info = InfoDialog(self.remote_branch)

681

else:

682

info = InfoDialog(self.wt.branch)

683

info.display()

684

685

def on_menuitem_stats_log_activate(self, widget):

686

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

687

688

if not self.remote:

689

branch = self.wt.branch

690

else:

691

branch = self.remote_branch

692

693

window = branchwin.BranchWindow(branch, [branch.last_revision()], None,

694

parent=self.window)

695

window.show()

696

697

def on_menuitem_view_refresh_activate(self, widget):

698

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

699

# Refresh the left pane

700

self.refresh_left()

701

# Refresh the right pane

702

self.refresh_right()

703

704

def on_menuitem_view_show_hidden_files_activate(self, widget):

705

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

706

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

707

if self.path is not None:

708

self.refresh_right()

709

710

def on_menuitem_view_show_ignored_files_activate(self, widget):

711

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

712

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

713

if self.path is not None:

714

self.refresh_right()

715

716

def on_treeview_left_button_press_event(self, widget, event):

717

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

718

treepathpos = widget.get_path_at_pos(int(event.x), int(event.y))

719

treeselection = widget.get_selection()

720

if treepathpos is not None:

721

treeselection.select_path(treepathpos[0])

722

if event.button == 1:

723

newdir = self.get_selected_left()

724

if newdir == None:

725

return

726

727

if self.set_path(newdir):

728

self.refresh_right()

729

elif event.button == 3:

730

# Don't show context with nothing selected

731

if self.get_selected_left() == None:

732

return

733

734

# Create a menu

735

from menu import OliveMenu

736

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

737

selected=self.get_selected_left(),

738

app=self)

739

740

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

741

event.time)

742

else:

743

if treeselection is not None:

744

treeselection.unselect_all()

745

746

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

747

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

748

bookmark list. """

749

750

newdir = self.get_selected_left()

751

if newdir == None:

752

return

753

754

if self.set_path(newdir):

755

self.refresh_right()

756

757

def on_treeview_right_button_press_event(self, widget, event):

758

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

759

treepathpos = widget.get_path_at_pos(int(event.x), int(event.y))

760

if event.button == 1:

761

if treepathpos is None and widget.get_selection is not None:

762

treeselection = widget.get_selection()

763

treeselection.unselect_all()

764

elif event.button == 3:

765

treeselection = widget.get_selection()

766

if treepathpos is not None:

767

treeselection.select_path(treepathpos[0])

768

else:

769

if treeselection is not None:

770

treeselection.unselect_all()

771

# Create a menu

772

from menu import OliveMenu

773

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

774

selected=self.get_selected_right(),

775

app=self)

776

# get the menu items

777

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

778

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

779

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

780

m_remove_and_delete = menu.ui.get_widget('/context_right/remove_and_delete')

781

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

782

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

783

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

784

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

785

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

786

# check if we're in a branch

787

try:

788

from bzrlib.branch import Branch

789

Branch.open_containing(self.get_path())

790

if self.remote:

791

m_open.set_sensitive(False)

792

m_add.set_sensitive(False)

793

m_remove.set_sensitive(False)

794

m_remove_and_delete.set_sensitive(False)

795

m_rename.set_sensitive(False)

796

m_revert.set_sensitive(False)

797

m_commit.set_sensitive(False)

798

m_annotate.set_sensitive(False)

799

m_diff.set_sensitive(False)

800

else:

801

if treepathpos is None:

802

m_open.set_sensitive(False)

803

m_add.set_sensitive(False)

804

m_remove.set_sensitive(False)

805

m_remove_and_delete.set_sensitive(False)

806

m_rename.set_sensitive(False)

807

m_annotate.set_sensitive(False)

808

m_diff.set_sensitive(False)

809

m_revert.set_sensitive(False)

810

else:

811

m_open.set_sensitive(True)

812

m_add.set_sensitive(True)

813

m_remove.set_sensitive(True)

814

m_remove_and_delete.set_sensitive(True)

815

m_rename.set_sensitive(True)

816

m_annotate.set_sensitive(True)

817

m_diff.set_sensitive(True)

818

m_revert.set_sensitive(True)

819

m_commit.set_sensitive(True)

820

except bzrerrors.NotBranchError:

821

if treepathpos is None:

822

m_open.set_sensitive(False)

823

else:

824

m_open.set_sensitive(True)

825

m_add.set_sensitive(False)

826

m_remove.set_sensitive(False)

827

m_remove_and_delete.set_sensitive(False)

828

m_rename.set_sensitive(False)

829

m_revert.set_sensitive(False)

830

m_commit.set_sensitive(False)

831

m_annotate.set_sensitive(False)

832

m_diff.set_sensitive(False)

833

834

if not self.remote:

835

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

836

event.time)

837

else:

838

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

839

event.time)

840

841

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

842

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

843

file list. """

844

from launch import launch

845

846

newdir = self.get_selected_right()

847

848

if not self.remote:

849

# We're local

850

if newdir == '..':

851

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

852

else:

853

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

854

if os.path.isdir(fullpath):

855

# selected item is an existant directory

856

self.set_path(fullpath)

857

else:

858

launch(fullpath)

859

else:

860

# We're remote

861

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

862

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

863

864

self.refresh_right()

865

866

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

867

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

868

width, height = self.window.get_size()

869

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

870

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

871

x, y = self.window.get_position()

872

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

873

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

874

self.pref.set_preference('paned_position',

875

self.window.hpaned_main.get_position())

876

877

self.pref.write()

878

self.window.destroy()

879

880

def get_selected_fileid(self):

881

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

882

treeselection = self.window.treeview_right.get_selection()

883

(model, iter) = treeselection.get_selected()

884

885

if iter is None:

886

return None

887

else:

888

return model.get_value(iter, 9)

889

890

def get_selected_right(self):

891

""" Get the selected filename. """

892

treeselection = self.window.treeview_right.get_selection()

893

(model, iter) = treeselection.get_selected()

894

895

if iter is None:

896

return None

897

else:

898

return model.get_value(iter, 2)

899

900

def get_selected_left(self):

901

""" Get the selected bookmark. """

902

treeselection = self.window.treeview_left.get_selection()

903

(model, iter) = treeselection.get_selected()

904

905

if iter is None:

906

return None

907

else:

908

return model.get_value(iter, 1)

909

910

def set_statusbar(self, message):

911

""" Set the statusbar message. """

912

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

913

914

def clear_statusbar(self):

915

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

916

self.window.statusbar.pop(self.context_id)

917

918

def set_sensitivity(self):

919

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

920

if not self.remote:

921

self.window.set_view_to_localbranch(self.notbranch)

922

else:

923

self.window.set_view_to_remotebranch()

924

925

def refresh_left(self):

926

""" Refresh the bookmark list. """

927

928

# Get ListStore and clear it

929

liststore = self.window.bookmarklist

930

liststore.clear()

931

932

# Re-read preferences

933

self.pref.read()

934

935

# Get bookmarks

936

bookmarks = self.pref.get_bookmarks()

937

938

# Get titles and sort by title

939

bookmarks = [[self.pref.get_bookmark_title(item), item, gtk.STOCK_DIRECTORY] for item in bookmarks]

940

bookmarks.sort()

941

for title_item in bookmarks:

942

liststore.append(title_item)

943

944

# Add the ListStore to the TreeView and refresh column width

945

self.window.treeview_left.set_model(liststore)

946

self.window.treeview_left.columns_autosize()

947

948

def refresh_right(self):

949

""" Refresh the file list. """

950

if not self.remote:

951

# We're local

952

from bzrlib.workingtree import WorkingTree

953

954

path = self.get_path()

955

956

# Get ListStore and clear it

957

liststore = self.window.filelist

958

liststore.clear()

959

960

dirs = []

961

files = []

962

963

# Fill the appropriate lists

964

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

965

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

966

967

for item in os.listdir(path):

968

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

969

continue

970

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

971

dirs.append(item)

972

else:

973

files.append(item)

974

975

self.window.col_status.set_visible(False)

976

if not self.notbranch:

977

try:

978

tree1 = WorkingTree.open_containing(os.path.realpath(path))[0]

979

branch = tree1.branch

980

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

981

982

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

983

984

# Show Status column

985

self.window.col_status.set_visible(True)

986

except bzrerrors.LockContention:

987

self.window.set_location_status(gtk.STOCK_DIALOG_ERROR, allowPopup=True)

988

self.window.location_status.connect_object('clicked', error_dialog,

989

*(_i18n('Branch is locked'),

990

_i18n('The branch in the current folder is locked by another Bazaar program')))

991

self.notbranch = True

992

self.window.set_view_to_localbranch(False)

993

994

# Add'em to the ListStore

995

for item in dirs:

996

status = ''

997

st = ''

998

fileid = ''

999

if not self.notbranch:

1000

filename = tree1.relpath(os.path.join(os.path.realpath(path), item))

1001

1002

st, status = self.statusmapper(filename, delta)

1003

if not ignored_files and status == 'ignored':

1004

continue

1005

1006

try:

1007

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

1008

except OSError, e:

1009

if e.errno in self.acceptable_errors:

1010

continue

1011

else:

1012

raise

1013

liststore.append([ gtk.STOCK_DIRECTORY,

1014

True,

1015

item,

1016

st,

1017

status,

1018

"<DIR>",

1019

"<DIR>",

1020

statinfo.st_mtime,

1021

self._format_date(statinfo.st_mtime),

1022

''])

1023

for item in files:

1024

status = ''

1025

st = ''

1026

fileid = ''

1027

if not self.notbranch:

1028

filename = tree1.relpath(os.path.join(os.path.realpath(path), item))

1029

1030

st, status = self.statusmapper(filename, delta)

1031

if not ignored_files and status == 'ignored':

1032

continue

1033

1034

try:

1035

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

1036

except OSError, e:

1037

if e.errno in self.acceptable_errors:

1038

continue

1039

else:

1040

raise

1041

liststore.append([gtk.STOCK_FILE,

1042

False,

1043

item,

1044

st,

1045

status,

1046

str(statinfo.st_size),

1047

self._format_size(statinfo.st_size),

1048

statinfo.st_mtime,

1049

self._format_date(statinfo.st_mtime),

1050

fileid])

1051

else:

1052

# We're remote

1053

1054

# Get ListStore and clear it

1055

liststore = self.window.filelist

1056

liststore.clear()

1057

1058

# Hide Status column

1059

self.window.col_status.set_visible(False)

1060

1061

dirs = []

1062

files = []

1063

1064

self.window.set_location_status(gtk.STOCK_REFRESH)

1065

1066

for (name, type) in self.remote_entries:

1067

if type.kind == 'directory':

1068

dirs.append(type)

1069

elif type.kind == 'file':

1070

files.append(type)

1071

1072

class HistoryCache:

1073

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

1074

def __init__(self, history):

1075

self._history = history

1076

1077

def _lookup_revision(self, revid):

1078

for r in self._history:

1079

if r.revision_id == revid:

1080

return r

1081

rev = repo.get_revision(revid)

1082

self._history.append(rev)

1083

return rev

1084

1085

repo = self.remote_branch.repository

1086

1087

revhistory = self.remote_branch.revision_history()

1088

try:

1089

revs = repo.get_revisions(revhistory)

1090

cache = HistoryCache(revs)

1091

except bzrerrors.InvalidHttpResponse:

1092

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

1093

cache = HistoryCache([])

1094

1095

for item in dirs:

1096

if item.parent_id == self.remote_parent:

1097

rev = cache._lookup_revision(item.revision)

1098

liststore.append([ gtk.STOCK_DIRECTORY,

1099

True,

1100

item.name,

1101

'',

1102

'',

1103

"<DIR>",

1104

"<DIR>",

1105

rev.timestamp,

1106

self._format_date(rev.timestamp),

1107

''

1108

])

1109

while gtk.events_pending():

1110

gtk.main_iteration()

1111

1112

for item in files:

1113

if item.parent_id == self.remote_parent:

1114

rev = cache._lookup_revision(item.revision)

1115

liststore.append([ gtk.STOCK_FILE,

1116

False,

1117

item.name,

1118

'',

1119

'',

1120

str(item.text_size),

1121

self._format_size(item.text_size),

1122

rev.timestamp,

1123

self._format_date(rev.timestamp),

1124

item.file_id

1125

])

1126

while gtk.events_pending():

1127

gtk.main_iteration()

1128

1129

self.window.location_status.destroy()

1130

1131

# Columns should auto-size

1132

self.window.treeview_right.columns_autosize()

1133

1134

# Set sensitivity

1135

self.set_sensitivity()

1136

1137

def statusmapper(self, filename, delta):

1138

status = 'unknown'

1139

try:

1140

self.wt.lock_read()

1141

1142

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

1143

if rpathnew == filename:

1144

status = 'renamed'

1145

fileid = id

1146

for rpath, id, kind in delta.added:

1147

if rpath == filename:

1148

status = 'added'

1149

fileid = id

1150

for rpath, id, kind in delta.removed:

1151

if rpath == filename:

1152

status = 'removed'

1153

fileid = id

1154

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

1155

if rpath == filename:

1156

status = 'modified'

1157

fileid = id

1158

for rpath, id, kind in delta.unchanged:

1159

if rpath == filename:

1160

status = 'unchanged'

1161

fileid = id

1162

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

1163

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

1164

status = 'ignored'

1165

finally:

1166

self.wt.unlock()

1167

1168

if status == 'renamed':

1169

st = _i18n('renamed')

1170

elif status == 'removed':

1171

st = _i18n('removed')

1172

elif status == 'added':

1173

st = _i18n('added')

1174

elif status == 'modified':

1175

st = _i18n('modified')

1176

elif status == 'unchanged':

1177

st = _i18n('unchanged')

1178

elif status == 'ignored':

1179

st = _i18n('ignored')

1180

else:

1181

st = _i18n('unknown')

1182

return st, status

1183

1184

def _harddisks(self):

1185

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

1186

try:

1187

import win32file

1188

import string

1189

except ImportError:

1190

if sys.platform == 'win32':

1191

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

1192

sys.exit(1)

1193

1194

driveletters = []

1195

for drive in string.ascii_uppercase:

1196

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

1197

win32file.GetDriveType(drive+':') == win32file.DRIVE_REMOTE or\

1198

win32file.GetDriveType(drive+':') == win32file.DRIVE_REMOVABLE:

1199

driveletters.append(drive+':')

1200

return driveletters

1201

1202

def gen_hard_selector(self):

1203

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

1204

drives = self._harddisks()

1205

for drive in drives:

1206

self.combobox_drive.append_text(drive)

1207

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

1208

1209

def _refresh_drives(self, combobox):

1210

if self._just_started:

1211

return

1212

model = combobox.get_model()

1213

active = combobox.get_active()

1214

if active >= 0:

1215

drive = model[active][0]

1216

self.set_path(drive + '\\')

1217

self.refresh_right()

1218

1219

def check_for_changes(self):

1220

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

1221

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

1222

delta = self.wt.changes_from(old_tree)

1223

1224

changes = False

1225

1226

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

1227

changes = True

1228

1229

return changes

1230

1231

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

1232

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

1233

-1: iter1 < iter2

1234

0: iter1 = iter2

1235

1: iter1 > iter2

1236

"""

1237

name1 = model.get_value(iter1, 2)

1238

name2 = model.get_value(iter2, 2)

1239

1240

if model.get_value(iter1, 1):

1241

# item1 is a directory

1242

if not model.get_value(iter2, 1):

1243

# item2 isn't

1244

return -1

1245

else:

1246

# both of them are directories, we compare their names

1247

if name1 < name2:

1248

return -1

1249

elif name1 == name2:

1250

return 0

1251

else:

1252

return 1

1253

else:

1254

# item1 is not a directory

1255

if model.get_value(iter2, 1):

1256

# item2 is

1257

return 1

1258

else:

1259

# both of them are files, compare them

1260

if name1 < name2:

1261

return -1

1262

elif name1 == name2:

1263

return 0

1264

else:

1265

return 1

1266

1267

def _format_size(self, size):

1268

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

1269

if size < 1000:

1270

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

1271

size = size / 1000.0

1272

1273

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

1274

if size < 1000:

1275

break

1276

size = size / 1000.0

1277

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

1278

1279

def _format_date(self, timestamp):

1280

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

1281

return time.ctime(timestamp)

1282

1283

def _is_remote_dir(self, location):

1284

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

1285

if not self.remote:

1286

# We're in local mode

1287

return False

1288

else:

1289

branch, path = Branch.open_containing(location)

1290

for (name, type) in self.remote_entries:

1291

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

1292

# We got it

1293

return True

1294

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

1295

return False

1296

1297

import ConfigParser

1298

1299

class Preferences:

1300

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

1301

def __init__(self, path=None):

1302

""" Initialize the Preferences class. """

1303

# Some default options

1304

self.defaults = { 'strict_commit' : False,

1305

'dotted_files' : False,

1306

'ignored_files' : True,

1307

'window_width' : 700,

1308

'window_height' : 400,

1309

'window_x' : 40,

1310

'window_y' : 40,

1311

'paned_position': 200 }

1312

1313

# Create a config parser object

1314

self.config = ConfigParser.RawConfigParser()

1315

1316

# Set filename

1317

if path is None:

1318

if sys.platform == 'win32':

1319

# Windows - no dotted files

1320

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

1321

else:

1322

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

1323

else:

1324

self._filename = path

1325

1326

# Load the configuration

1327

self.read()

1328

1329

def _get_default(self, option):

1330

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

1331

try:

1332

ret = self.defaults[option]

1333

except KeyError:

1334

return None

1335

else:

1336

return ret

1337

1338

def refresh(self):

1339

""" Refresh the configuration. """

1340

# First write out the changes

1341

self.write()

1342

# Then load the configuration again

1343

self.read()

1344

1345

def read(self):

1346

""" Just read the configuration. """

1347

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

1348

self.config = ConfigParser.RawConfigParser()

1349

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

1350

1351

def write(self):

1352

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

1353

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

1354

self.config.write(fp)

1355

fp.close()

1356

1357

def get_bookmarks(self):

1358

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

1359

bookmarks = self.config.sections()

1360

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

1361

bookmarks.remove('preferences')

1362

return bookmarks

1363

1364

def add_bookmark(self, path):

1365

""" Add bookmark. """

1366

try:

1367

self.config.add_section(path)

1368

except ConfigParser.DuplicateSectionError:

1369

return False

1370

else:

1371

return True

1372

1373

def get_bookmark_title(self, path):

1374

""" Get bookmark title. """

1375

try:

1376

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

1377

except ConfigParser.NoOptionError:

1378

ret = path

1379

1380

return ret

1381

1382

def set_bookmark_title(self, path, title):

1383

""" Set bookmark title. """

1384

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

1385

# FIXME: Canonicalize paths first?

1386

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

1387

1388

def remove_bookmark(self, path):

1389

""" Remove bookmark. """

1390

return self.config.remove_section(path)

1391

1392

def set_preference(self, option, value):

1393

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

1394

if value is True:

1395

value = 'yes'

1396

elif value is False:

1397

value = 'no'

1398

1399

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

1400

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

1401

else:

1402

self.config.add_section('preferences')

1403

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

1404

1405

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

1406

""" Get the value of the given option.

1407

1408

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

1409

"""

1410

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

1411

if kind == 'bool':

1412

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

1413

elif kind == 'int':

1414

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

1415

elif kind == 'float':

1416

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

1417

else:

1418

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

1419

else:

1420

try:

1421

return self._get_default(option)

1422

except KeyError:

1423

return None