~ubuntu-branches/ubuntu/karmic/chmsee/karmic : revision 8

28

* (at your option) any later version. *

29

***************************************************************************/

30

31

#include "config.h"

31

32

#include "chmsee.h"

32

33

34

#include <stdio.h>

42

43

#include <gdk/gdkkeysyms.h>

43

44

#include <glade/glade.h>

44

45

#include "html.h"

46

#include "ihtml.h"

47

#include "html-factory.h"

46

48

#include "booktree.h"

47

49

#include "ui_bookmarks.h"

48

50

#include "setup.h"

49

51

#include "link.h"

50

#include "utils.h"

52

#include "utils/utils.h"

53

54

#include "models/chmfile-factory.h"

55

56

struct _ChmSeePrivate {

57

GtkWidget *control_notebook;

58

GtkWidget *html_notebook;

59

60

GtkWidget *booktree;

61

GtkWidget *bookmark_tree;

62

GtkWidget *index_tree;

63

64

GtkWidget *statusbar;

65

guint scid_default;

66

67

gboolean has_toc;

68

gboolean has_index;

69

gint pos_x;

70

gint pos_y;

71

gint width;

72

gint height;

73

gint hpaned_position;

74

gint lang;

75

gboolean fullscreen;

76

77

ChmseeIchmfile *book;

78

79

gchar *home;

80

gchar *cache_dir;

81

gchar *last_dir;

82

};

83

84

#define selfp (self->priv)

85

#define CHMSEE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TYPE_CHMSEE, ChmSeePrivate))

51

86

52

87

static void chmsee_class_init(ChmSeeClass *);

53

88

static void chmsee_init(ChmSee *);

54

89

static void chmsee_finalize(GObject *);

90

static void chmsee_dispose(GObject* self);

91

static void chmsee_load_config(ChmSee *self);

92

static void chmsee_save_config(ChmSee *self);

93

static void chmsee_set_fullscreen(ChmSee* self, gboolean fullscreen);

55

94

56

95

static gboolean delete_cb(GtkWidget *, GdkEvent *, ChmSee *);

57

96

static void destroy_cb(GtkWidget *, ChmSee *);

58

static gboolean configure_event_cb(GtkWidget *, GdkEventConfigure *, ChmSee *);

97

static gboolean on_configure_event(GtkWidget *, GdkEventConfigure *, ChmSee *);

59

98

60

static gboolean keypress_event_cb(GtkWidget *, GdkEventKey *, ChmSee *);

99

static gboolean on_keypress_event(GtkWidget *, GdkEventKey *, ChmSee *);

61

100

static void open_response_cb(GtkWidget *, gint, ChmSee *);

62

101

static void about_response_cb(GtkDialog *, gint, gpointer);

63

102

static void booktree_link_selected_cb(GObject *, Link *, ChmSee *);

64

103

static void bookmarks_link_selected_cb(GObject *, Link *, ChmSee *);

65

104

static void control_switch_page_cb(GtkNotebook *, GtkNotebookPage *, guint , ChmSee *);

66

105

static void html_switch_page_cb(GtkNotebook *, GtkNotebookPage *, guint , ChmSee *);

67

static void html_location_changed_cb(Html *, const gchar *, ChmSee *);

68

static gboolean html_open_uri_cb(Html *, const gchar *, ChmSee *);

69

static void html_title_changed_cb(Html *, const gchar *, ChmSee *);

70

static void html_context_normal_cb(Html *, ChmSee *);

71

static void html_context_link_cb(Html *, const gchar *, ChmSee *);

72

static void html_open_new_tab_cb(Html *, const gchar *, ChmSee *);

73

static void html_link_message_cb(Html *, const gchar *, ChmSee *);

106

static void html_location_changed_cb(ChmseeIhtml *, const gchar *, ChmSee *);

107

static gboolean html_open_uri_cb(ChmseeIhtml *, const gchar *, ChmSee *);

108

static void html_title_changed_cb(ChmseeIhtml *, const gchar *, ChmSee *);

109

static void html_context_normal_cb(ChmseeIhtml *, ChmSee *);

110

static void html_context_link_cb(ChmseeIhtml *, const gchar *, ChmSee *);

111

static void html_open_new_tab_cb(ChmseeIhtml *, const gchar *, ChmSee *);

112

static void html_link_message_cb(ChmseeIhtml *, const gchar *, ChmSee *);

113

static void show_sidepane(ChmSee* self);

114

static void hide_sidepane(ChmSee* self);

115

static void set_sidepane_state(ChmSee* self, gboolean state);

74

116

75

117

static void on_open(GtkWidget *, ChmSee *);

76

118

static void on_close_tab(GtkWidget *, ChmSee *);

89

131

static void on_close_current_tab(GtkWidget *, ChmSee *);

90

132

static void on_context_new_tab(GtkWidget *, ChmSee *);

91

133

static void on_context_copy_link(GtkWidget *, ChmSee *);

134

static void on_fullscreen_toggled(ChmSee* self, GtkWidget* menu);

135

static void on_sidepane_toggled(ChmSee* self, GtkWidget* menu);

136

static void on_map(ChmSee* self);

137

static gboolean on_window_state_event(ChmSee* self, GdkEventWindowState* event);

138

static gboolean on_scroll_event(ChmSee* self, GdkEventScroll* event);

92

139

93

140

static void chmsee_quit(ChmSee *);

94

141

static void chmsee_open_uri(ChmSee *chmsee, const gchar *uri);

142

static void chmsee_open_file(ChmSee *self, const gchar *filename);

95

143

static GtkWidget *get_widget(ChmSee *, gchar *);

96

static void window_populate(ChmSee *);

97

static void display_book(ChmSee *, ChmFile *);

144

static void populate_window(ChmSee *);

145

static void display_book(ChmSee *, ChmseeIchmfile *);

98

146

static void close_current_book(ChmSee *);

99

147

static void new_tab(ChmSee *, const gchar *);

100

static Html *get_active_html(ChmSee *);

101

static void check_history(ChmSee *, Html *);

102

static void update_tab_title(ChmSee *, Html *);

103

static void tab_set_title(ChmSee *, Html *, const gchar *);

148

static ChmseeIhtml *get_active_html(ChmSee *);

149

static void check_history(ChmSee *, ChmseeIhtml *);

150

static void update_tab_title(ChmSee *, ChmseeIhtml *);

151

static void tab_set_title(ChmSee *, ChmseeIhtml *, const gchar *);

104

152

static void open_homepage(ChmSee *);

105

153

static void reload_current_page(ChmSee *);

106

154

static void update_status_bar(ChmSee *, const gchar *);

114

162

guint time);

115

163

116

164

static gchar *context_menu_link = NULL;

117

static GtkWindowClass *parent_class = NULL;

118

165

static const GtkTargetEntry view_drop_targets[] = {

119

166

{ "text/uri-list", 0, 0 }

120

167

};

121

168

122

GType

123

chmsee_get_type(void)

124

{

125

static GType type = 0;

126

127

if (!type) {

128

static const GTypeInfo info = {

129

sizeof(ChmSeeClass),

130

NULL,

131

NULL,

132

(GClassInitFunc)chmsee_class_init,

133

NULL,

134

NULL,

135

sizeof(ChmSee),

136

0,

137

(GInstanceInitFunc)chmsee_init,

138

};

139

140

type = g_type_register_static(GTK_TYPE_WINDOW,

141

"ChmSee",

142

&info, 0);

143

}

144

145

return type;

146

}

169

G_DEFINE_TYPE (ChmSee, chmsee, GTK_TYPE_WINDOW);

147

170

148

171

static void

149

172

chmsee_class_init(ChmSeeClass *klass)

150

173

{

151

GObjectClass *object_class = G_OBJECT_CLASS(klass);

152

GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass);

153

parent_class = g_type_class_peek_parent(klass);

154

155

object_class->finalize = chmsee_finalize;

156

widget_class->drag_data_received = chmsee_drag_data_received;

174

g_type_class_add_private(klass, sizeof(ChmSeePrivate));

175

G_OBJECT_CLASS(klass)->finalize = chmsee_finalize;

176

G_OBJECT_CLASS(klass)->dispose = chmsee_dispose;

177

GTK_WIDGET_CLASS(klass)->drag_data_received = chmsee_drag_data_received;

157

178

}

158

179

159

180

static void

160

chmsee_init(ChmSee *chmsee)

181

chmsee_init(ChmSee* self)

161

182

{

162

chmsee->home = g_build_filename(g_get_home_dir(), ".chmsee", NULL);

163

164

g_debug("chmsee home = %s", chmsee->home);

165

166

if (!g_file_test(chmsee->home, G_FILE_TEST_IS_DIR))

167

mkdir(chmsee->home, 0777);

168

169

chmsee->cache_dir = g_build_filename(chmsee->home, "bookshelf", NULL);

170

171

if (!g_file_test(chmsee->cache_dir, G_FILE_TEST_IS_DIR))

172

mkdir(chmsee->cache_dir, 0777);

173

174

chmsee->lang = 0;

175

chmsee->last_dir = g_strdup(g_get_home_dir());

176

177

chmsee->book = NULL;

178

chmsee->html_notebook = NULL;

179

chmsee->pos_x = -100;

180

chmsee->pos_y = -100;

181

chmsee->width = 0;

182

chmsee->height = 0;

183

chmsee->has_toc = FALSE;

184

chmsee->has_index = FALSE;

185

186

g_signal_connect(G_OBJECT (chmsee),

187

"key-press-event",

188

G_CALLBACK (keypress_event_cb),

189

chmsee);

190

gtk_drag_dest_set (GTK_WIDGET (chmsee),

191

GTK_DEST_DEFAULT_ALL,

192

view_drop_targets,

193

G_N_ELEMENTS (view_drop_targets),

194

GDK_ACTION_COPY);

183

self->priv = CHMSEE_GET_PRIVATE(self);

184

selfp->home = g_build_filename(g_get_home_dir(), ".chmsee", NULL);

185

186

g_debug("chmsee home = %s", selfp->home);

187

188

if (!g_file_test(selfp->home, G_FILE_TEST_IS_DIR))

189

mkdir(selfp->home, 0777);

190

191

selfp->cache_dir = g_build_filename(selfp->home, "bookshelf", NULL);

192

193

if (!g_file_test(selfp->cache_dir, G_FILE_TEST_IS_DIR))

194

mkdir(selfp->cache_dir, 0777);

195

196

selfp->lang = 0;

197

selfp->last_dir = g_strdup(g_get_home_dir());

198

199

selfp->book = NULL;

200

selfp->html_notebook = NULL;

201

selfp->pos_x = -100;

202

selfp->pos_y = -100;

203

selfp->width = 0;

204

selfp->height = 0;

205

selfp->hpaned_position = -1;

206

selfp->has_toc = FALSE;

207

selfp->has_index = FALSE;

208

selfp->fullscreen = FALSE;

209

210

gtk_widget_add_events(GTK_WIDGET(self),

211

GDK_STRUCTURE_MASK | GDK_BUTTON_PRESS_MASK );

212

213

g_signal_connect(G_OBJECT (self),

214

"key-press-event",

215

G_CALLBACK (on_keypress_event),

216

self);

217

g_signal_connect(G_OBJECT(self),

218

"scroll-event",

219

G_CALLBACK(on_scroll_event),

220

NULL);

221

g_signal_connect(G_OBJECT(self),

222

"map",

223

G_CALLBACK(on_map),

224

NULL);

225

g_signal_connect(G_OBJECT(self),

226

"window-state-event",

227

G_CALLBACK(on_window_state_event),

228

NULL);

229

gtk_drag_dest_set (GTK_WIDGET (self),

230

GTK_DEST_DEFAULT_ALL,

231

view_drop_targets,

232

G_N_ELEMENTS (view_drop_targets),

233

GDK_ACTION_COPY);

195

234

196

235

}

197

236

198

237

static void

199

238

chmsee_finalize(GObject *object)

200

239

{

201

G_OBJECT_CLASS (parent_class)->finalize (object);

202

}

240

ChmSee* self = CHMSEE(object);

241

242

if(selfp->home) {

243

g_free(selfp->home);

244

selfp->home = NULL;

245

}

246

247

if(selfp->cache_dir) {

248

g_free(selfp->cache_dir);

249

selfp->cache_dir = NULL;

250

}

251

252

if(selfp->last_dir) {

253

g_free(selfp->last_dir);

254

selfp->last_dir = NULL;

255

}

256

G_OBJECT_CLASS (chmsee_parent_class)->finalize (object);

257

}

258

259

static void chmsee_dispose(GObject* gobject)

260

{

261

ChmSee* self = CHMSEE(gobject);

262

263

if(selfp->book) {

264

g_object_unref(selfp->book);

265

selfp->book = NULL;

266

}

267

268

if(selfp->html_notebook) {

269

g_object_unref(selfp->html_notebook);

270

selfp->html_notebook = NULL;

271

}

272

273

G_OBJECT_CLASS(chmsee_parent_class)->dispose(gobject);

274

}

275

203

276

204

277

/* callbacks */

205

278

217

290

}

218

291

219

292

static gboolean

220

configure_event_cb(GtkWidget *widget, GdkEventConfigure *event, ChmSee *chmsee)

221

{

222

if (chmsee->html_notebook != NULL

223

&& (event->width != chmsee->width || event->height != chmsee->height))

224

reload_current_page(chmsee);

225

226

chmsee->width = event->width;

227

chmsee->height = event->height;

228

chmsee->pos_x = event->x;

229

chmsee->pos_y = event->y;

230

231

return FALSE;

232

}

233

234

static gboolean

235

keypress_event_cb(GtkWidget *widget, GdkEventKey *event, ChmSee *chmsee)

236

{

237

if (event->keyval == GDK_Escape) {

238

gtk_window_iconify(GTK_WINDOW (chmsee));

239

return TRUE;

293

on_configure_event(GtkWidget *widget, GdkEventConfigure *event, ChmSee *self)

294

{

295

if (selfp->html_notebook != NULL

296

&& (event->width != selfp->width || event->height != selfp->height))

297

reload_current_page(self);

298

299

if(!selfp->fullscreen) {

300

selfp->width = event->width;

301

selfp->height = event->height;

302

selfp->pos_x = event->x;

303

selfp->pos_y = event->y;

240

304

}

241

305

242

306

return FALSE;

243

307

}

244

308

309

static gboolean

310

on_keypress_event(GtkWidget *widget, GdkEventKey *event, ChmSee *self)

311

{

312

if (event->keyval == GDK_Escape) {

313

if(selfp->fullscreen) {

314

chmsee_set_fullscreen(self, FALSE);

315

} else {

316

gtk_window_iconify(GTK_WINDOW (self));

317

return TRUE;

318

}

319

} else if(event->keyval == GDK_F11) {

320

if(selfp->fullscreen) {

321

chmsee_set_fullscreen(self, FALSE);

322

}

323

} else if(event->keyval == GDK_F9) {

324

if(selfp->fullscreen) {

325

set_sidepane_state(self,

326

!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(get_widget(self, "menu_sidepane"))));

327

}

328

}

329

330

return FALSE;

331

}

332

245

333

static void

246

334

open_response_cb(GtkWidget *widget, gint response_id, ChmSee *chmsee)

247

335

{

259

347

}

260

348

261

349

static void

262

booktree_link_selected_cb(GObject *ignored, Link *link, ChmSee *chmsee)

350

booktree_link_selected_cb(GObject *ignored, Link *link, ChmSee *self)

263

351

{

264

Html *html;

352

ChmseeIhtml* html;

265

353

266

354

g_debug("booktree link selected: %s", link->uri);

267

355

if (!g_ascii_strcasecmp(CHMSEE_NO_LINK, link->uri))

268

356

return;

269

357

270

html = get_active_html(chmsee);

271

272

g_signal_handlers_block_by_func(html, html_open_uri_cb, chmsee);

273

274

html_open_uri(html, g_build_filename(chmsee->book->dir, link->uri, NULL));

275

276

g_signal_handlers_unblock_by_func(html, html_open_uri_cb, chmsee);

277

278

check_history(chmsee, html);

358

html = get_active_html(self);

359

360

g_signal_handlers_block_by_func(html, html_open_uri_cb, self);

361

362

chmsee_ihtml_open_uri(html, g_build_filename(

363

chmsee_ichmfile_get_dir(selfp->book), link->uri, NULL));

364

365

g_signal_handlers_unblock_by_func(html, html_open_uri_cb, self);

366

367

check_history(self, html);

279

368

}

280

369

281

370

static void

282

371

bookmarks_link_selected_cb(GObject *ignored, Link *link, ChmSee *chmsee)

283

372

{

284

Html *html;

285

286

html = get_active_html(chmsee);

287

html_open_uri(html, link->uri);

288

check_history(chmsee, html);

373

chmsee_ihtml_open_uri(get_active_html(chmsee), link->uri);

374

check_history(chmsee, get_active_html(chmsee));

289

375

}

290

376

291

377

static void

295

381

}

296

382

297

383

static void

298

html_switch_page_cb(GtkNotebook *notebook, GtkNotebookPage *page, guint new_page_num, ChmSee *chmsee)

384

html_switch_page_cb(GtkNotebook *notebook, GtkNotebookPage *page, guint new_page_num, ChmSee *self)

299

385

{

300

386

GtkWidget *new_page;

301

387

302

388

new_page = gtk_notebook_get_nth_page(notebook, new_page_num);

303

389

304

390

if (new_page) {

305

Html *new_html;

306

gchar *title, *location;

391

ChmseeIhtml* new_html;

392

const gchar* title;

393

const gchar* location;

307

394

308

395

new_html = g_object_get_data(G_OBJECT (new_page), "html");

309

396

310

update_tab_title(chmsee, new_html);

397

update_tab_title(self, new_html);

311

398

312

title = html_get_title(new_html);

313

location = html_get_location(new_html);

399

title = chmsee_ihtml_get_title(new_html);

400

location = chmsee_ihtml_get_location(new_html);

314

401

315

402

if (location != NULL && strlen(location)) {

316

403

if (strlen(title)) {

317

ui_bookmarks_set_current_link(UIBOOKMARKS (chmsee->bookmark_tree), title, location);

404

ui_bookmarks_set_current_link(UIBOOKMARKS (selfp->bookmark_tree), title, location);

318

405

} else {

319

406

const gchar *book_title;

320

321

book_title = booktree_get_selected_book_title(BOOKTREE (chmsee->booktree));

322

ui_bookmarks_set_current_link(UIBOOKMARKS (chmsee->bookmark_tree), book_title, location);

407

408

book_title = booktree_get_selected_book_title(BOOKTREE (selfp->booktree));

409

ui_bookmarks_set_current_link(UIBOOKMARKS (selfp->bookmark_tree), book_title, location);

323

410

}

324

411

325

412

/* Sync the book tree. */

326

if (chmsee->has_toc)

327

booktree_select_uri(BOOKTREE (chmsee->booktree), location);

413

if (selfp->has_toc)

414

booktree_select_uri(BOOKTREE (selfp->booktree), location);

328

415

}

329

416

330

check_history(chmsee, new_html);

417

check_history(self, new_html);

331

418

} else {

332

gtk_window_set_title(GTK_WINDOW (chmsee), "ChmSee");

333

check_history(chmsee, NULL);

419

gtk_window_set_title(GTK_WINDOW (self), "ChmSee");

420

check_history(self, NULL);

334

421

}

335

422

}

336

423

337

424

static void

338

html_location_changed_cb(Html *html, const gchar *location, ChmSee *chmsee)

425

html_location_changed_cb(ChmseeIhtml *html, const gchar *location, ChmSee *chmsee)

339

426

{

340

427

g_debug("html location changed cb: %s", location);

341

428

344

431

}

345

432

346

433

static gboolean

347

html_open_uri_cb(Html *html, const gchar *uri, ChmSee *chmsee)

434

html_open_uri_cb(ChmseeIhtml* html, const gchar *uri, ChmSee *self)

348

435

{

349

436

static const char* prefix = "file://";

350

437

static int prefix_len = 7;

351

438

352

439

if(g_str_has_prefix(uri, prefix)) {

353

440

/* FIXME: can't disable the DND function of GtkMozEmbed */

354

441

if(g_str_has_suffix(uri, ".chm")

355

442

|| g_str_has_suffix(uri, ".CHM")) {

356

chmsee_open_uri(chmsee, uri);

443

chmsee_open_uri(self, uri);

357

444

}

358

445

359

446

if(g_access(uri+prefix_len, R_OK) < 0) {

360

447

gchar* newfname = correct_filename(uri+prefix_len);

361

448

if(newfname) {

362

449

g_message(_("URI redirect: \"%s\" -> \"%s\""), uri, newfname);

363

html_open_uri(html, newfname);

450

chmsee_ihtml_open_uri(html, newfname);

364

451

g_free(newfname);

365

452

return TRUE;

366

453

}

367

454

}

368

455

}

369

456

370

if ((html == get_active_html(chmsee)) && chmsee->has_toc)

371

booktree_select_uri(BOOKTREE (chmsee->booktree), uri);

457

if ((html == get_active_html(self)) && selfp->has_toc)

458

booktree_select_uri(BOOKTREE (selfp->booktree), uri);

372

459

373

460

return FALSE;

374

461

}

375

462

376

463

static void

377

html_title_changed_cb(Html *html, const gchar *title, ChmSee *chmsee)

464

html_title_changed_cb(ChmseeIhtml *html, const gchar *title, ChmSee *self)

378

465

{

379

gchar *location;

466

const gchar *location;

380

467

381

468

g_debug("html title changed cb %s", title);

382

469

383

update_tab_title(chmsee, get_active_html(chmsee));

470

update_tab_title(self, get_active_html(self));

384

471

385

location = html_get_location(html);

472

location = chmsee_ihtml_get_location(html);

386

473

387

474

if (location != NULL && strlen(location)) {

388

475

if (strlen(title))

389

ui_bookmarks_set_current_link(UIBOOKMARKS (chmsee->bookmark_tree), title, location);

476

ui_bookmarks_set_current_link(UIBOOKMARKS (selfp->bookmark_tree), title, location);

390

477

else {

391

478

const gchar *book_title;

392

393

book_title = booktree_get_selected_book_title(BOOKTREE (chmsee->booktree));

394

ui_bookmarks_set_current_link(UIBOOKMARKS (chmsee->bookmark_tree), book_title, location);

479

480

book_title = booktree_get_selected_book_title(BOOKTREE (selfp->booktree));

481

ui_bookmarks_set_current_link(UIBOOKMARKS (selfp->bookmark_tree), book_title, location);

395

482

}

396

483

}

397

484

}

398

485

399

486

/* Popup html context menu */

400

487

static void

401

html_context_normal_cb(Html *html, ChmSee *chmsee)

488

html_context_normal_cb(ChmseeIhtml *html, ChmSee *chmsee)

402

489

{

403

490

GladeXML *glade;

404

491

GtkWidget *menu;

408

495

409

496

g_message("html context-normal event");

410

497

411

back_state = html_can_go_back(html);

412

forward_state = html_can_go_forward(html);

498

back_state = chmsee_ihtml_can_go_back(html);

499

forward_state = chmsee_ihtml_can_go_forward(html);

413

500

414

glade = glade_xml_new(CHMSEE_DATA_DIR"/"GLADE_FILE, "html_context_normal", NULL);

501

glade = glade_xml_new(get_resource_path(GLADE_FILE), "html_context_normal", NULL);

415

502

menu = glade_xml_get_widget(glade, "html_context_normal");

416

503

417

504

menu_item = glade_xml_get_widget(glade, "menu_back");

418

g_signal_connect(G_OBJECT (menu_item),

505

g_signal_connect(G_OBJECT (menu_item),

419

506

"activate",

420

507

G_CALLBACK (on_back),

421

508

chmsee);

422

509

gtk_widget_set_sensitive(menu_item, back_state);

423

510

424

511

menu_item = glade_xml_get_widget(glade, "menu_forward");

425

g_signal_connect(G_OBJECT (menu_item),

512

g_signal_connect(G_OBJECT (menu_item),

426

513

"activate",

427

514

G_CALLBACK (on_forward),

428

515

chmsee);

429

516

gtk_widget_set_sensitive(menu_item, forward_state);

430

517

431

518

menu_item = glade_xml_get_widget(glade, "menu_copy");

432

g_signal_connect(G_OBJECT (menu_item),

519

g_signal_connect(G_OBJECT (menu_item),

433

520

"activate",

434

521

G_CALLBACK (on_copy),

435

522

chmsee);

436

523

437

524

menu_item = glade_xml_get_widget(glade, "menu_select_all");

438

g_signal_connect(G_OBJECT (menu_item),

525

g_signal_connect(G_OBJECT (menu_item),

439

526

"activate",

440

527

G_CALLBACK (on_select_all),

441

528

chmsee);

452

539

453

540

/* Popup html context menu when mouse over hyper link */

454

541

static void

455

html_context_link_cb(Html *html, const gchar *link, ChmSee *chmsee)

542

html_context_link_cb(ChmseeIhtml *html, const gchar *link, ChmSee *chmsee)

456

543

{

457

544

GladeXML *glade;

458

545

GtkWidget *menu;

464

551

465

552

context_menu_link = g_strdup(link);

466

553

467

glade = glade_xml_new(CHMSEE_DATA_DIR"/"GLADE_FILE, "html_context_link", NULL);

554

glade = glade_xml_new(get_resource_path(GLADE_FILE), "html_context_link", NULL);

468

555

menu = glade_xml_get_widget(glade, "html_context_link");

469

556

470

557

menu_item = glade_xml_get_widget(glade, "menu_new_tab");

471

g_signal_connect(G_OBJECT (menu_item),

558

g_signal_connect(G_OBJECT (menu_item),

472

559

"activate",

473

560

G_CALLBACK (on_context_new_tab),

474

561

chmsee);

487

574

}

488

575

489

576

static void

490

html_open_new_tab_cb(Html *html, const gchar *location, ChmSee *chmsee)

577

html_open_new_tab_cb(ChmseeIhtml *html, const gchar *location, ChmSee *chmsee)

491

578

{

492

579

g_debug("html open new tab callback: %s", location);

493

580

495

582

}

496

583

497

584

static void

498

html_link_message_cb(Html *html, const gchar *url, ChmSee *chmsee)

585

html_link_message_cb(ChmseeIhtml *html, const gchar *url, ChmSee *chmsee)

499

586

{

500

587

update_status_bar(chmsee, url);

501

588

}

503

590

/* Toolbar button events */

504

591

505

592

static void

506

on_open(GtkWidget *widget, ChmSee *chmsee)

593

on_open(GtkWidget *widget, ChmSee *self)

507

594

{

508

595

GladeXML *glade;

509

596

GtkWidget *dialog;

510

597

GtkFileFilter *filter;

511

598

512

599

/* create openfile dialog */

513

glade = glade_xml_new(CHMSEE_DATA_DIR"/"GLADE_FILE, "openfile_dialog", NULL);

600

glade = glade_xml_new(get_resource_path(GLADE_FILE), "openfile_dialog", NULL);

514

601

dialog = glade_xml_get_widget(glade, "openfile_dialog");

515

602

516

603

g_signal_connect(G_OBJECT (dialog),

517

604

"response",

518

605

G_CALLBACK (open_response_cb),

519

chmsee);

606

self);

520

607

521

608

/* File list fiter */

522

609

filter = gtk_file_filter_new();

530

617

gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filter);

531

618

532

619

/* Previous opened folder */

533

if (chmsee->last_dir)

534

gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), chmsee->last_dir);

620

if (selfp->last_dir) {

621

gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), selfp->last_dir);

622

}

535

623

536

624

g_object_unref(glade);

537

625

}

538

626

539

627

static void

540

on_close_tab(GtkWidget *widget, ChmSee *chmsee)

628

on_close_tab(GtkWidget *widget, ChmSee *self)

541

629

{

542

630

gint num_pages, number, i;

543

631

GtkWidget *tab_label, *page;

544

632

545

633

number = -1;

546

num_pages = gtk_notebook_get_n_pages(GTK_NOTEBOOK (chmsee->html_notebook));

634

num_pages = gtk_notebook_get_n_pages(GTK_NOTEBOOK (selfp->html_notebook));

547

635

548

636

if (num_pages == 1) {

549

chmsee_quit(chmsee);

637

chmsee_quit(self);

550

638

551

639

return;

552

640

}

553

641

554

642

for (i = 0; i < num_pages; i++) {

555

643

GList *children, *l;

556

644

557

645

g_debug("page %d", i);

558

page = gtk_notebook_get_nth_page(GTK_NOTEBOOK (chmsee->html_notebook), i);

646

page = gtk_notebook_get_nth_page(GTK_NOTEBOOK (selfp->html_notebook), i);

559

647

560

tab_label = gtk_notebook_get_tab_label(GTK_NOTEBOOK (chmsee->html_notebook), page);

648

tab_label = gtk_notebook_get_tab_label(GTK_NOTEBOOK (selfp->html_notebook), page);

561

649

g_message("tab_label");

562

650

children = gtk_container_get_children(GTK_CONTAINER (tab_label));

563

651

570

658

}

571

659

572

660

if (number >= 0) {

573

gtk_notebook_remove_page(GTK_NOTEBOOK (chmsee->html_notebook), number);

661

gtk_notebook_remove_page(GTK_NOTEBOOK (selfp->html_notebook), number);

574

662

575

663

break;

576

664

}

578

666

}

579

667

580

668

static void

581

on_copy(GtkWidget *widget, ChmSee *chmsee)

669

on_copy(GtkWidget *widget, ChmSee *self)

582

670

{

583

Html *html;

584

585

671

g_message("On Copy");

586

672

587

g_return_if_fail(GTK_IS_NOTEBOOK (chmsee->html_notebook));

673

g_return_if_fail(GTK_IS_NOTEBOOK (selfp->html_notebook));

588

674

589

html = get_active_html(chmsee);

590

html_copy_selection(html);

675

chmsee_ihtml_copy_selection(get_active_html(self));

591

676

}

592

677

593

678

static void

594

679

on_copy_page_location(GtkWidget* widget, ChmSee* chmsee) {

595

Html* html = get_active_html(chmsee);

596

gchar* location = html_get_location(html);

680

ChmseeIhtml* html = get_active_html(chmsee);

681

const gchar* location = chmsee_ihtml_get_location(html);

597

682

if(!location) return;

598

683

599

684

gtk_clipboard_set_text(

600

685

gtk_clipboard_get(GDK_SELECTION_PRIMARY),

601

686

location,

607

692

}

608

693

609

694

static void

610

on_select_all(GtkWidget *widget, ChmSee *chmsee)

695

on_select_all(GtkWidget *widget, ChmSee *self)

611

696

{

612

Html *html;

697

ChmseeIhtml *html;

613

698

614

699

g_message("On Select All");

615

700

616

g_return_if_fail(GTK_IS_NOTEBOOK (chmsee->html_notebook));

701

g_return_if_fail(GTK_IS_NOTEBOOK (selfp->html_notebook));

617

702

618

html = get_active_html(chmsee);

619

html_select_all(html);

703

html = get_active_html(self);

704

chmsee_ihtml_select_all(html);

620

705

}

621

706

622

707

static void

625

710

setup_window_new(chmsee);

626

711

}

627

712

628

static void

713

static void

629

714

on_back(GtkWidget *widget, ChmSee *chmsee)

630

715

{

631

Html *html;

632

633

html = get_active_html(chmsee);

634

html_go_back(html);

716

chmsee_ihtml_go_back(get_active_html(chmsee));

635

717

}

636

718

637

static void

719

static void

638

720

on_forward(GtkWidget *widget, ChmSee *chmsee)

639

721

{

640

Html *html;

641

642

html = get_active_html(chmsee);

643

html_go_forward(html);

644

}

645

646

static void

647

on_home(GtkWidget *widget, ChmSee *chmsee)

648

{

649

if (chmsee->book->home != NULL)

650

open_homepage(chmsee);

651

}

652

653

static void

654

on_zoom_in(GtkWidget *widget, ChmSee *chmsee)

655

{

656

Html *html;

657

658

html = get_active_html(chmsee);

659

html_increase_size(html);

722

chmsee_ihtml_go_forward(get_active_html(chmsee));

723

}

724

725

static void

726

on_home(GtkWidget *widget, ChmSee *self)

727

{

728

if (chmsee_ichmfile_get_home(selfp->book) != NULL) {

729

open_homepage(self);

730

}

731

}

732

733

static void

734

on_zoom_in(GtkWidget *widget, ChmSee *self)

735

{

736

ChmseeIhtml* html = get_active_html(self);

737

if(html != NULL) {

738

chmsee_ihtml_increase_size(html);

739

}

660

740

}

661

741

662

742

static void

663

743

on_zoom_reset(GtkWidget *widget, ChmSee *chmsee)

664

744

{

665

Html *html;

666

667

html = get_active_html(chmsee);

668

html_reset_size(html);

745

chmsee_ihtml_reset_size(get_active_html(chmsee));

669

746

}

670

747

671

748

static void

672

on_zoom_out(GtkWidget *widget, ChmSee *chmsee)

749

on_zoom_out(GtkWidget *widget, ChmSee *self)

673

750

{

674

Html *html;

675

676

html = get_active_html(chmsee);

677

html_decrease_size(html);

751

ChmseeIhtml* html = get_active_html(self);

752

if(html != NULL) {

753

chmsee_ihtml_decrease_size(html);

754

}

678

755

}

679

756

680

757

static void

684

761

gtk_widget_destroy(GTK_WIDGET (dialog));

685

762

}

686

763

687

static void

764

static void

688

765

on_about(GtkWidget *widget)

689

766

{

690

767

GladeXML *glade;

691

768

GtkWidget *dialog;

692

769

693

glade = glade_xml_new(CHMSEE_DATA_DIR"/"GLADE_FILE, "about_dialog", NULL);

770

glade = glade_xml_new(get_resource_path(GLADE_FILE), "about_dialog", NULL);

694

771

dialog = glade_xml_get_widget(glade, "about_dialog");

695

772

696

g_signal_connect(G_OBJECT (dialog),

773

g_signal_connect(G_OBJECT (dialog),

697

774

"response",

698

775

G_CALLBACK (about_response_cb),

699

776

NULL);

704

781

}

705

782

706

783

static void

707

hpanes_toggled_cb(GtkToggleToolButton *widget, ChmSee *chmsee)

784

hpanes_toggled_cb(GtkToggleToolButton *widget, ChmSee *self)

708

785

{

709

786

gboolean state;

710

GtkWidget *icon_widget;

711

GtkWidget *control_vbox;

712

713

787

g_object_get(widget, "active", &state, NULL);

714

g_debug("hpanes_toggled: %d", state);

715

716

control_vbox = get_widget(chmsee, "control_vbox");

717

718

if (state) {

719

icon_widget = gtk_image_new_from_file(CHMSEE_DATA_DIR"/hide-pane.png");

720

gtk_widget_show(control_vbox);

721

} else {

722

icon_widget = gtk_image_new_from_file(CHMSEE_DATA_DIR"/show-pane.png");

723

gtk_widget_hide(control_vbox);

724

}

725

726

reload_current_page(chmsee);

727

gtk_widget_show(icon_widget);

728

gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON (widget), icon_widget);

788

set_sidepane_state(self, state);

729

789

}

730

790

731

791

static void

732

on_open_new_tab(GtkWidget *widget, ChmSee *chmsee)

792

on_open_new_tab(GtkWidget *widget, ChmSee *self)

733

793

{

734

Html *html;

735

gchar *location;

794

ChmseeIhtml *html;

795

const gchar *location;

736

796

737

797

g_message("Open new tab");

738

798

739

g_return_if_fail(GTK_IS_NOTEBOOK (chmsee->html_notebook));

740

741

html = get_active_html(chmsee);

742

location = html_get_location(html);

743

744

if (location != NULL)

745

new_tab(chmsee, location);

746

747

g_free(location);

799

g_return_if_fail(GTK_IS_NOTEBOOK (selfp->html_notebook));

800

801

html = get_active_html(self);

802

location = chmsee_ihtml_get_location(html);

803

804

if (location != NULL) {

805

new_tab(self, location);

806

}

748

807

}

749

808

750

809

static void

751

on_close_current_tab(GtkWidget *widget, ChmSee *chmsee)

810

on_close_current_tab(GtkWidget *widget, ChmSee *self)

752

811

{

753

g_return_if_fail(GTK_IS_NOTEBOOK (chmsee->html_notebook));

812

g_return_if_fail(GTK_IS_NOTEBOOK (selfp->html_notebook));

754

813

755

if (gtk_notebook_get_n_pages(GTK_NOTEBOOK (chmsee->html_notebook)) == 1)

756

return chmsee_quit(chmsee);

814

if (gtk_notebook_get_n_pages(GTK_NOTEBOOK (selfp->html_notebook)) == 1)

815

return chmsee_quit(self);

757

816

758

817

gint page_num;

759

818

760

page_num = gtk_notebook_get_current_page(GTK_NOTEBOOK (chmsee->html_notebook));

819

page_num = gtk_notebook_get_current_page(GTK_NOTEBOOK (selfp->html_notebook));

761

820

762

821

if (page_num >= 0)

763

gtk_notebook_remove_page(GTK_NOTEBOOK (chmsee->html_notebook), page_num);

822

gtk_notebook_remove_page(GTK_NOTEBOOK (selfp->html_notebook), page_num);

764

823

}

765

824

766

825

static void

778

837

g_debug("On context copy link: %s", context_menu_link);

779

838

780

839

if (context_menu_link != NULL) {

781

gtk_clipboard_set_text(gtk_clipboard_get(GDK_SELECTION_PRIMARY),

840

gtk_clipboard_set_text(gtk_clipboard_get(GDK_SELECTION_PRIMARY),

782

841

context_menu_link, -1);

783

842

gtk_clipboard_set_text(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD),

784

843

context_menu_link, -1);

789

848

/* internal functions */

790

849

791

850

static void

792

chmsee_quit(ChmSee *chmsee)

851

chmsee_quit(ChmSee *self)

793

852

{

794

if (chmsee->book) {

795

close_current_book(chmsee);

853

if (selfp->book) {

854

close_current_book(self);

796

855

}

797

856

798

save_chmsee_config(chmsee);

857

chmsee_save_config(self);

799

858

800

g_free(chmsee->home);

801

g_free(chmsee->cache_dir);

802

g_free(chmsee->last_dir);

803

859

g_free(context_menu_link);

804

html_shutdown(get_active_html(chmsee));

860

861

if(get_active_html(self)) {

862

chmsee_ihtml_shutdown(get_active_html(self));

863

}

805

864

806

865

gtk_main_quit();

807

exit(0);

808

809

g_message("chmsee quit");

810

866

}

811

867

812

868

static GtkWidget *

818

874

glade = g_object_get_data(G_OBJECT (chmsee), "glade");

819

875

820

876

widget = GTK_WIDGET (glade_xml_get_widget(glade, widget_name));

821

877

822

878

return widget;

823

879

}

824

880

825

881

static void

826

window_populate(ChmSee *chmsee)

882

populate_window(ChmSee *self)

827

883

{

828

884

GladeXML *glade;

829

885

830

glade = glade_xml_new(CHMSEE_DATA_DIR"/"GLADE_FILE, "main_vbox", NULL);

886

glade = glade_xml_new(get_resource_path(GLADE_FILE), "main_vbox", NULL);

831

887

832

888

if (glade == NULL) {

833

889

g_error("Cannot find glade file!");

834

890

exit(1);

835

891

}

836

892

837

g_object_set_data(G_OBJECT (chmsee), "glade", glade);

893

g_object_set_data(G_OBJECT (self), "glade", glade);

838

894

839

895

GtkWidget *main_vbox;

840

main_vbox = get_widget(chmsee, "main_vbox");

841

gtk_container_add(GTK_CONTAINER (chmsee), main_vbox);

896

main_vbox = get_widget(self, "main_vbox");

897

gtk_container_add(GTK_CONTAINER (self), main_vbox);

842

898

843

899

GtkAccelGroup *accel_group;

844

900

845

901

accel_group = g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);

846

gtk_window_add_accel_group(GTK_WINDOW (chmsee), accel_group);

902

gtk_window_add_accel_group(GTK_WINDOW (self), accel_group);

847

903

848

904

/* menu item */

849

905

GtkWidget *menu_item;

850

906

851

menu_item = get_widget(chmsee, "menu_open");

907

menu_item = get_widget(self, "menu_open");

852

908

g_signal_connect(G_OBJECT (menu_item),

853

909

"activate",

854

910

G_CALLBACK (on_open),

855

chmsee);

911

self);

856

912

gtk_widget_add_accelerator(menu_item,

857

913

"activate",

858

914

accel_group,

860

916

GDK_CONTROL_MASK,

861

917

GTK_ACCEL_VISIBLE);

862

918

863

menu_item = get_widget(chmsee, "menu_new_tab");

919

menu_item = get_widget(self, "menu_new_tab");

864

920

g_signal_connect(G_OBJECT (menu_item),

865

921

"activate",

866

922

G_CALLBACK (on_open_new_tab),

867

chmsee);

923

self);

868

924

gtk_widget_add_accelerator(menu_item,

869

925

"activate",

870

926

accel_group,

873

929

GTK_ACCEL_VISIBLE);

874

930

gtk_widget_set_sensitive(menu_item, FALSE);

875

931

876

menu_item = get_widget(chmsee, "menu_close_tab");

932

menu_item = get_widget(self, "menu_close_tab");

877

933

g_signal_connect(G_OBJECT (menu_item),

878

934

"activate",

879

935

G_CALLBACK (on_close_current_tab),

880

chmsee);

936

self);

881

937

gtk_widget_add_accelerator(menu_item,

882

938

"activate",

883

939

accel_group,

886

942

GTK_ACCEL_VISIBLE);

887

943

gtk_widget_set_sensitive(menu_item, FALSE);

888

944

889

menu_item = get_widget(chmsee, "menu_setup");

945

menu_item = get_widget(self, "menu_setup");

890

946

g_signal_connect(G_OBJECT (menu_item),

891

947

"activate",

892

948

G_CALLBACK (on_setup),

893

chmsee);

949

self);

894

950

895

menu_item = get_widget(chmsee, "menu_copy");

951

menu_item = get_widget(self, "menu_copy");

896

952

g_signal_connect(G_OBJECT (menu_item),

897

953

"activate",

898

954

G_CALLBACK (on_copy),

899

chmsee);

955

self);

900

956

gtk_widget_add_accelerator(menu_item,

901

957

"activate",

902

958

accel_group,

904

960

GDK_CONTROL_MASK,

905

961

GTK_ACCEL_VISIBLE);

906

962

907

menu_item = get_widget(chmsee, "menu_quit");

963

menu_item = get_widget(self, "menu_quit");

908

964

g_signal_connect(G_OBJECT (menu_item),

909

965

"activate",

910

966

G_CALLBACK (destroy_cb),

911

chmsee);

967

self);

912

968

gtk_widget_add_accelerator(menu_item,

913

969

"activate",

914

970

accel_group,

916

972

GDK_CONTROL_MASK,

917

973

GTK_ACCEL_VISIBLE);

918

974

919

menu_item = get_widget(chmsee, "menu_home");

975

menu_item = get_widget(self, "menu_home");

920

976

g_signal_connect(G_OBJECT (menu_item),

921

977

"activate",

922

978

G_CALLBACK (on_home),

923

chmsee);

979

self);

924

980

gtk_widget_set_sensitive(menu_item, FALSE);

925

981

926

menu_item = get_widget(chmsee, "menu_back");

982

menu_item = get_widget(self, "menu_back");

927

983

g_signal_connect(G_OBJECT (menu_item),

928

984

"activate",

929

985

G_CALLBACK (on_back),

930

chmsee);

986

self);

931

987

gtk_widget_set_sensitive(menu_item, FALSE);

932

988

933

menu_item = get_widget(chmsee, "menu_forward");

989

menu_item = get_widget(self, "menu_forward");

934

990

g_signal_connect(G_OBJECT (menu_item),

935

991

"activate",

936

992

G_CALLBACK (on_forward),

937

chmsee);

993

self);

938

994

gtk_widget_set_sensitive(menu_item, FALSE);

939

995

940

menu_item = get_widget(chmsee, "menu_about");

996

menu_item = get_widget(self, "menu_fullscreen");

997

g_signal_connect_swapped(G_OBJECT(menu_item),

998

"toggled",

999

G_CALLBACK(on_fullscreen_toggled),

1000

self);

1001

gtk_widget_add_accelerator(menu_item,

1002

"activate",

1003

accel_group,

1004

GDK_F11,

1005

0,

1006

GTK_ACCEL_VISIBLE);

1007

1008

menu_item = get_widget(self, "menu_sidepane");

1009

g_signal_connect_swapped(G_OBJECT(menu_item),

1010

"toggled",

1011

G_CALLBACK(on_sidepane_toggled),

1012

self);

1013

gtk_widget_add_accelerator(menu_item,

1014

"activate",

1015

accel_group,

1016

GDK_F9,

1017

0,

1018

GTK_ACCEL_VISIBLE);

1019

1020

menu_item = get_widget(self, "menu_about");

941

1021

g_signal_connect(G_OBJECT (menu_item),

942

1022

"activate",

943

1023

G_CALLBACK (on_about),

944

chmsee);

1024

self);

945

1025

946

1026

/* toolbar buttons */

947

1027

GtkWidget *toolbar_button;

948

1028

GtkWidget *icon_widget;

949

1029

950

toolbar_button = get_widget(chmsee, "toolbar_open");

1030

toolbar_button = get_widget(self, "toolbar_open");

951

1031

g_signal_connect(G_OBJECT (toolbar_button),

952

1032

"clicked",

953

1033

G_CALLBACK (on_open),

954

chmsee);

1034

self);

955

1035

956

toolbar_button = get_widget(chmsee, "toolbar_setup");

1036

toolbar_button = get_widget(self, "toolbar_setup");

957

1037

g_signal_connect(G_OBJECT (toolbar_button),

958

1038

"clicked",

959

1039

G_CALLBACK (on_setup),

960

chmsee);

1040

self);

961

1041

962

toolbar_button = get_widget(chmsee, "toolbar_about");

1042

toolbar_button = get_widget(self, "toolbar_about");

963

1043

g_signal_connect(G_OBJECT (toolbar_button),

964

1044

"clicked",

965

1045

G_CALLBACK (on_about),

966

1046

NULL);

967

1047

968

toolbar_button = get_widget(chmsee, "toolbar_hpanes");

969

icon_widget = gtk_image_new_from_file(CHMSEE_DATA_DIR"/show-pane.png");

1048

toolbar_button = get_widget(self, "toolbar_hpanes");

1049

icon_widget = gtk_image_new_from_file(get_resource_path("show-pane.png"));

970

1050

gtk_widget_show(icon_widget);

971

1051

gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON (toolbar_button), icon_widget);

972

1052

g_object_set(toolbar_button, "active", FALSE, NULL);

974

1054

g_signal_connect(G_OBJECT (toolbar_button),

975

1055

"toggled",

976

1056

G_CALLBACK (hpanes_toggled_cb),

977

chmsee);

1057

self);

978

1058

979

toolbar_button = get_widget(chmsee, "toolbar_back");

1059

toolbar_button = get_widget(self, "toolbar_back");

980

1060

g_signal_connect(G_OBJECT (toolbar_button),

981

1061

"clicked",

982

1062

G_CALLBACK (on_back),

983

chmsee);

1063

self);

984

1064

gtk_widget_add_accelerator(toolbar_button,

985

1065

"clicked",

986

1066

accel_group,

988

1068

GDK_MOD1_MASK,

989

1069

GTK_ACCEL_VISIBLE);

990

1070

991

toolbar_button = get_widget(chmsee, "toolbar_forward");

1071

toolbar_button = get_widget(self, "toolbar_forward");

992

1072

g_signal_connect(G_OBJECT (toolbar_button),

993

1073

"clicked",

994

1074

G_CALLBACK (on_forward),

995

chmsee);

1075

self);

996

1076

gtk_widget_add_accelerator(toolbar_button,

997

1077

"clicked",

998

1078

accel_group,

1000

1080

GDK_MOD1_MASK,

1001

1081

GTK_ACCEL_VISIBLE);

1002

1082

1003

toolbar_button = get_widget(chmsee, "toolbar_home");

1083

toolbar_button = get_widget(self, "toolbar_home");

1004

1084

g_signal_connect(G_OBJECT (toolbar_button),

1005

1085

"clicked",

1006

1086

G_CALLBACK (on_home),

1007

chmsee);

1087

self);

1008

1088

1009

toolbar_button = get_widget(chmsee, "toolbar_zoom_in");

1089

toolbar_button = get_widget(self, "toolbar_zoom_in");

1010

1090

g_signal_connect(G_OBJECT (toolbar_button),

1011

1091

"clicked",

1012

1092

G_CALLBACK (on_zoom_in),

1013

chmsee);

1093

self);

1014

1094

gtk_widget_add_accelerator(toolbar_button,

1015

1095

"clicked",

1016

1096

accel_group,

1019

1099

GTK_ACCEL_VISIBLE);

1020

1100

1021

1101

1022

toolbar_button = get_widget(chmsee, "toolbar_zoom_reset");

1102

toolbar_button = get_widget(self, "toolbar_zoom_reset");

1023

1103

g_signal_connect(G_OBJECT (toolbar_button),

1024

1104

"clicked",

1025

1105

G_CALLBACK (on_zoom_reset),

1026

chmsee);

1106

self);

1027

1107

gtk_widget_add_accelerator(toolbar_button,

1028

1108

"clicked",

1029

1109

accel_group,

1031

1111

GDK_CONTROL_MASK,

1032

1112

GTK_ACCEL_VISIBLE);

1033

1113

1034

toolbar_button = get_widget(chmsee, "toolbar_zoom_out");

1114

toolbar_button = get_widget(self, "toolbar_zoom_out");

1035

1115

g_signal_connect(G_OBJECT (toolbar_button),

1036

1116

"clicked",

1037

1117

G_CALLBACK (on_zoom_out),

1038

chmsee);

1118

self);

1039

1119

gtk_widget_add_accelerator(toolbar_button,

1040

1120

"clicked",

1041

1121

accel_group,

1045

1125

1046

1126

GtkWidget *control_vbox;

1047

1127

1048

control_vbox = get_widget(chmsee, "control_vbox");

1128

control_vbox = get_widget(self, "control_vbox");

1049

1129

gtk_widget_hide(control_vbox);

1050

1130

1051

1131

/* status bar */

1052

chmsee->statusbar = glade_xml_get_widget(glade, "statusbar1");

1053

chmsee->scid_default = gtk_statusbar_get_context_id(GTK_STATUSBAR (chmsee->statusbar),

1132

selfp->statusbar = glade_xml_get_widget(glade, "statusbar");

1133

selfp->scid_default = gtk_statusbar_get_context_id(GTK_STATUSBAR (selfp->statusbar),

1054

1134

"default");

1055

update_status_bar(chmsee, _("Ready!"));

1056

}

1057

1058

static void

1059

display_book(ChmSee *chmsee, ChmFile *book)

1060

{

1061

GNode *link_tree;

1062

GList *bookmarks_list;

1063

1064

GtkWidget *booktree_sw;

1065

GtkWidget *control_vbox;

1066

1067

g_message("display book");

1068

1069

/* Close currently opened book */

1070

if (chmsee->book)

1071

close_current_book(chmsee);

1072

1073

chmsee->book = book;

1074

1075

control_vbox = get_widget(chmsee, "control_vbox");

1076

1077

/* Book contents TreeView widget */

1078

chmsee->control_notebook = gtk_notebook_new();

1079

1080

gtk_box_pack_start(GTK_BOX (control_vbox),

1081

GTK_WIDGET (chmsee->control_notebook),

1082

TRUE,

1083

TRUE,

1084

2);

1085

g_signal_connect(G_OBJECT (chmsee->control_notebook),

1086

"switch-page",

1087

G_CALLBACK (control_switch_page_cb),

1088

chmsee);

1089

1090

/* TOC */

1091

if (chmsee->book->link_tree != NULL) {

1092

link_tree = chmsee->book->link_tree;

1093

1094

booktree_sw = gtk_scrolled_window_new(NULL, NULL);

1095

gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (booktree_sw),

1096

GTK_POLICY_NEVER,

1097

GTK_POLICY_AUTOMATIC);

1098

gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (booktree_sw),

1099

GTK_SHADOW_IN);

1100

gtk_container_set_border_width(GTK_CONTAINER (booktree_sw), 2);

1101

1102

chmsee->booktree = GTK_WIDGET (booktree_new(link_tree));

1103

1104

gtk_container_add(GTK_CONTAINER (booktree_sw), chmsee->booktree);

1105

gtk_notebook_append_page(GTK_NOTEBOOK (chmsee->control_notebook),

1106

booktree_sw,

1107

gtk_label_new(_("Topics")));

1108

1109

g_signal_connect(G_OBJECT (chmsee->booktree),

1110

"link-selected",

1111

G_CALLBACK (booktree_link_selected_cb),

1112

chmsee);

1113

1114

g_message("chmsee has toc");

1115

chmsee->has_toc = TRUE;

1116

}

1117

1118

/* Bookmarks */

1119

bookmarks_list = chmsee->book->bookmarks_list;

1120

chmsee->bookmark_tree = GTK_WIDGET (ui_bookmarks_new(bookmarks_list));

1121

1122

gtk_notebook_append_page(GTK_NOTEBOOK (chmsee->control_notebook),

1123

chmsee->bookmark_tree,

1124

gtk_label_new (_("Bookmarks")));

1125

1126

g_signal_connect(G_OBJECT (chmsee->bookmark_tree),

1127

"link-selected",

1128

G_CALLBACK (bookmarks_link_selected_cb),

1129

chmsee);

1130

1131

GtkWidget *hpaned;

1132

1133

hpaned = get_widget(chmsee, "hpaned1");

1134

1135

/* HTML tabs notebook */

1136

chmsee->html_notebook = gtk_notebook_new();

1137

gtk_paned_add2 (GTK_PANED (hpaned), chmsee->html_notebook);

1138

1139

g_signal_connect(G_OBJECT (chmsee->html_notebook),

1140

"switch-page",

1141

G_CALLBACK (html_switch_page_cb),

1142

chmsee);

1143

1144

gtk_widget_show_all(hpaned);

1145

new_tab(chmsee, NULL);

1146

1147

gtk_notebook_set_current_page(GTK_NOTEBOOK (chmsee->control_notebook),

1148

g_list_length(bookmarks_list) && chmsee->has_toc ? 1 : 0);

1149

1150

/* Toolbar buttons state */

1151

GtkWidget *toolbar_button;

1152

1153

toolbar_button = get_widget(chmsee, "toolbar_hpanes");

1154

gtk_widget_set_sensitive(toolbar_button, TRUE);

1155

g_object_set(toolbar_button, "active", TRUE, NULL);

1156

1157

toolbar_button = get_widget(chmsee, "toolbar_zoom_in");

1158

gtk_widget_set_sensitive(toolbar_button, TRUE);

1159

toolbar_button = get_widget(chmsee, "toolbar_zoom_reset");

1160

gtk_widget_set_sensitive(toolbar_button, TRUE);

1161

toolbar_button = get_widget(chmsee, "toolbar_zoom_out");

1162

gtk_widget_set_sensitive(toolbar_button, TRUE);

1163

1164

if (chmsee->book->home) {

1165

GtkWidget *menu_item;

1166

1167

open_homepage(chmsee);

1168

1169

menu_item = get_widget(chmsee, "menu_new_tab");

1170

gtk_widget_set_sensitive(menu_item, TRUE);

1171

1172

menu_item = get_widget(chmsee, "menu_close_tab");

1173

gtk_widget_set_sensitive(menu_item, TRUE);

1174

1175

menu_item = get_widget(chmsee, "menu_home");

1176

gtk_widget_set_sensitive(menu_item, TRUE);

1177

1178

toolbar_button = get_widget(chmsee, "toolbar_home");

1179

gtk_widget_set_sensitive(toolbar_button, TRUE);

1180

}

1181

1182

/* Window title */

1183

gchar *window_title;

1184

1185

if (chmsee->book->title != NULL && g_ascii_strcasecmp(chmsee->book->title, "(null)") != 0 )

1186

window_title = g_strdup_printf("%s - ChmSee", chmsee->book->title);

1187

else

1188

window_title = g_strdup("ChmSee");

1189

1190

gtk_window_set_title(GTK_WINDOW (chmsee), window_title);

1191

g_free(window_title);

1192

1193

html_set_variable_font(get_active_html(chmsee), chmsee->book->variable_font);

1194

html_set_fixed_font(get_active_html(chmsee), chmsee->book->fixed_font);

1195

}

1196

1197

static void

1198

close_current_book(ChmSee *chmsee)

1199

{

1200

gchar* bookmark_fname = g_build_filename(chmsee->book->dir, BOOKMARK_FILE, NULL);

1201

bookmarks_save(ui_bookmarks_get_list(UIBOOKMARKS (chmsee->bookmark_tree)), bookmark_fname);

1135

update_status_bar(self, _("Ready!"));

1136

}

1137

1138

static void

1139

display_book(ChmSee* self, ChmseeIchmfile *book)

1140

{

1141

GNode *link_tree;

1142

GList *bookmarks_list;

1143

1144

GtkWidget *booktree_sw;

1145

GtkWidget *control_vbox;

1146

1147

g_debug("display book");

1148

1149

/* Close currently opened book */

1150

if (selfp->book)

1151

close_current_book(self);

1152

1153

selfp->book = book;

1154

1155

control_vbox = get_widget(self, "control_vbox");

1156

1157

/* Book contents TreeView widget */

1158

selfp->control_notebook = gtk_notebook_new();

1159

1160

gtk_box_pack_start(GTK_BOX (control_vbox),

1161

GTK_WIDGET (selfp->control_notebook),

1162

TRUE,

1163

TRUE,

1164

2);

1165

g_signal_connect(G_OBJECT (selfp->control_notebook),

1166

"switch-page",

1167

G_CALLBACK (control_switch_page_cb),

1168

self);

1169

1170

/* TOC */

1171

if (chmsee_ichmfile_get_link_tree(selfp->book) != NULL) {

1172

link_tree = chmsee_ichmfile_get_link_tree(selfp->book);

1173

1174

booktree_sw = gtk_scrolled_window_new(NULL, NULL);

1175

gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (booktree_sw),

1176

GTK_POLICY_NEVER,

1177

GTK_POLICY_AUTOMATIC);

1178

gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (booktree_sw),

1179

GTK_SHADOW_IN);

1180

gtk_container_set_border_width(GTK_CONTAINER (booktree_sw), 2);

1181

1182

selfp->booktree = GTK_WIDGET(g_object_ref_sink(booktree_new(link_tree)));

1183

g_signal_connect_swapped(selfp->booktree,

1184

"scroll-event",

1185

G_CALLBACK(on_scroll_event),

1186

self);

1187

1188

gtk_container_add(GTK_CONTAINER (booktree_sw), selfp->booktree);

1189

gtk_notebook_append_page(GTK_NOTEBOOK (selfp->control_notebook),

1190

booktree_sw,

1191

gtk_label_new(_("Topics")));

1192

1193

g_signal_connect(G_OBJECT (selfp->booktree),

1194

"link-selected",

1195

G_CALLBACK (booktree_link_selected_cb),

1196

self);

1197

1198

g_debug("chmsee has toc");

1199

selfp->has_toc = TRUE;

1200

}

1201

1202

/* Bookmarks */

1203

bookmarks_list = chmsee_ichmfile_get_bookmarks_list(selfp->book);

1204

selfp->bookmark_tree = GTK_WIDGET (ui_bookmarks_new(bookmarks_list));

1205

1206

gtk_notebook_append_page(GTK_NOTEBOOK (selfp->control_notebook),

1207

selfp->bookmark_tree,

1208

gtk_label_new (_("Bookmarks")));

1209

1210

g_signal_connect(G_OBJECT (selfp->bookmark_tree),

1211

"link-selected",

1212

G_CALLBACK (bookmarks_link_selected_cb),

1213

self);

1214

1215

GtkWidget *hpaned;

1216

1217

hpaned = get_widget(self, "hpaned1");

1218

1219

/* HTML tabs notebook */

1220

selfp->html_notebook = gtk_notebook_new();

1221

gtk_paned_add2 (GTK_PANED (hpaned), selfp->html_notebook);

1222

1223

g_signal_connect(G_OBJECT (selfp->html_notebook),

1224

"switch-page",

1225

G_CALLBACK (html_switch_page_cb),

1226

self);

1227

1228

gtk_widget_show_all(hpaned);

1229

new_tab(self, NULL);

1230

1231

gtk_notebook_set_current_page(GTK_NOTEBOOK (selfp->control_notebook),

1232

g_list_length(bookmarks_list) && selfp->has_toc ? 1 : 0);

1233

1234

/* Toolbar buttons state */

1235

GtkWidget *toolbar_button;

1236

1237

toolbar_button = get_widget(self, "toolbar_hpanes");

1238

gtk_widget_set_sensitive(toolbar_button, TRUE);

1239

g_object_set(toolbar_button, "active", TRUE, NULL);

1240

1241

toolbar_button = get_widget(self, "toolbar_zoom_in");

1242

gtk_widget_set_sensitive(toolbar_button, TRUE);

1243

toolbar_button = get_widget(self, "toolbar_zoom_reset");

1244

gtk_widget_set_sensitive(toolbar_button, TRUE);

1245

toolbar_button = get_widget(self, "toolbar_zoom_out");

1246

gtk_widget_set_sensitive(toolbar_button, TRUE);

1247

1248

if (chmsee_ichmfile_get_home(selfp->book)) {

1249

GtkWidget *menu_item;

1250

1251

open_homepage(self);

1252

1253

menu_item = get_widget(self, "menu_new_tab");

1254

gtk_widget_set_sensitive(menu_item, TRUE);

1255

1256

menu_item = get_widget(self, "menu_close_tab");

1257

gtk_widget_set_sensitive(menu_item, TRUE);

1258

1259

menu_item = get_widget(self, "menu_home");

1260

gtk_widget_set_sensitive(menu_item, TRUE);

1261

1262

gtk_widget_set_sensitive(get_widget(self, "menu_sidepane"), TRUE);

1263

1264

toolbar_button = get_widget(self, "toolbar_home");

1265

gtk_widget_set_sensitive(toolbar_button, TRUE);

1266

}

1267

1268

/* Window title */

1269

gchar *window_title;

1270

1271

if (chmsee_ichmfile_get_title(selfp->book) != NULL

1272

&& g_ascii_strcasecmp(chmsee_ichmfile_get_title(selfp->book), "(null)") != 0 ) {

1273

window_title = g_strdup_printf("%s - ChmSee", chmsee_ichmfile_get_title(selfp->book));

1274

} else {

1275

window_title = g_strdup("ChmSee");

1276

}

1277

1278

gtk_window_set_title(GTK_WINDOW (self), window_title);

1279

g_free(window_title);

1280

1281

chmsee_ihtml_set_variable_font(get_active_html(self),

1282

chmsee_ichmfile_get_variable_font(selfp->book));

1283

chmsee_ihtml_set_fixed_font(get_active_html(self),

1284

chmsee_ichmfile_get_fixed_font(selfp->book));

1285

}

1286

1287

static void

1288

close_current_book(ChmSee *self)

1289

{

1290

gchar* bookmark_fname = g_build_filename(chmsee_ichmfile_get_dir(selfp->book), CHMSEE_BOOKMARK_FILE, NULL);

1291

bookmarks_save(ui_bookmarks_get_list(UIBOOKMARKS (selfp->bookmark_tree)), bookmark_fname);

1202

1292

g_free(bookmark_fname);

1203

g_object_unref(chmsee->book);

1204

gtk_widget_destroy(GTK_WIDGET (chmsee->control_notebook));

1205

gtk_widget_destroy(GTK_WIDGET (chmsee->html_notebook));

1293

g_object_unref(selfp->book);

1294

gtk_widget_destroy(GTK_WIDGET (selfp->control_notebook));

1295

gtk_widget_destroy(GTK_WIDGET (selfp->html_notebook));

1296

1297

selfp->book = NULL;

1298

selfp->control_notebook = NULL;

1299

selfp->html_notebook = NULL;

1206

1300

}

1207

1301

1208

1302

static GtkWidget*

1240

1334

}

1241

1335

1242

1336

static void

1243

new_tab(ChmSee *chmsee, const gchar *location)

1337

new_tab(ChmSee *self, const gchar *location)

1244

1338

{

1245

Html *html;

1339

ChmseeIhtml *html;

1246

1340

GtkWidget *frame;

1247

1341

GtkWidget *view;

1248

1342

GtkWidget *tab_content;

1254

1348

if (location != NULL && !g_str_has_prefix(location, "file://"))

1255

1349

return;

1256

1350

1257

html = html_new();

1351

html = chmsee_html_new();

1352

g_signal_connect_swapped(chmsee_ihtml_get_widget(html),

1353

"dom-mouse-click",

1354

G_CALLBACK(on_scroll_event),

1355

self);

1258

1356

1259

view = html_get_widget(html);

1357

view = chmsee_ihtml_get_widget(html);

1260

1358

gtk_widget_show(view);

1261

1359

1262

1360

frame = gtk_frame_new(NULL);

1269

1367

g_object_set_data(G_OBJECT (frame), "html", html);

1270

1368

1271

1369

/* Custom label widget, with a close button */

1272

tab_content = new_tab_content(chmsee, _("No Title"));

1370

tab_content = new_tab_content(self, _("No Title"));

1273

1371

1274

1372

g_signal_connect(G_OBJECT (html),

1275

1373

"title-changed",

1276

1374

G_CALLBACK (html_title_changed_cb),

1277

chmsee);

1375

self);

1278

1376

g_signal_connect(G_OBJECT (html),

1279

1377

"open-uri",

1280

1378

G_CALLBACK (html_open_uri_cb),

1281

chmsee);

1379

self);

1282

1380

g_signal_connect(G_OBJECT (html),

1283

1381

"location-changed",

1284

1382

G_CALLBACK (html_location_changed_cb),

1285

chmsee);

1383

self);

1286

1384

g_signal_connect(G_OBJECT (html),

1287

1385

"context-normal",

1288

1386

G_CALLBACK (html_context_normal_cb),

1289

chmsee);

1387

self);

1290

1388

g_signal_connect(G_OBJECT (html),

1291

1389

"context-link",

1292

1390

G_CALLBACK (html_context_link_cb),

1293

chmsee);

1391

self);

1294

1392

g_signal_connect(G_OBJECT (html),

1295

1393

"open-new-tab",

1296

1394

G_CALLBACK (html_open_new_tab_cb),

1297

chmsee);

1395

self);

1298

1396

g_signal_connect(G_OBJECT (html),

1299

1397

"link-message",

1300

1398

G_CALLBACK (html_link_message_cb),

1301

chmsee);

1399

self);

1400

g_signal_connect_swapped(chmsee_ihtml_get_widget(html),

1401

"scroll-event",

1402

G_CALLBACK(on_scroll_event),

1403

self);

1302

1404

1303

num = gtk_notebook_append_page(GTK_NOTEBOOK (chmsee->html_notebook),

1405

num = gtk_notebook_append_page(GTK_NOTEBOOK (selfp->html_notebook),

1304

1406

frame, tab_content);

1305

1407

1306

gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK (chmsee->html_notebook),

1408

gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK (selfp->html_notebook),

1307

1409

frame,

1308

1410

TRUE, TRUE,

1309

1411

GTK_PACK_START);

1311

1413

gtk_widget_realize(view);

1312

1414

1313

1415

if (location != NULL) {

1314

html_open_uri(html, location);

1315

1316

if (chmsee->has_toc)

1317

booktree_select_uri(BOOKTREE (chmsee->booktree), location);

1318

} else

1319

html_clear(html);

1320

1321

gtk_notebook_set_current_page(GTK_NOTEBOOK (chmsee->html_notebook), num);

1322

}

1323

1324

static void

1325

open_homepage(ChmSee *chmsee)

1326

{

1327

Html *html;

1328

1329

html = get_active_html(chmsee);

1330

1331

g_signal_handlers_block_by_func(html, html_open_uri_cb, chmsee);

1332

1333

html_open_uri(html, g_build_filename(chmsee->book->dir, chmsee->book->home, NULL));

1334

1335

g_signal_handlers_unblock_by_func(html, html_open_uri_cb, chmsee);

1336

1337

if (chmsee->has_toc)

1338

booktree_select_uri(BOOKTREE (chmsee->booktree), chmsee->book->home);

1339

1340

check_history(chmsee, html);

1341

}

1342

1343

static void

1344

reload_current_page(ChmSee *chmsee)

1345

{

1346

Html *html;

1347

gchar *location;

1416

chmsee_ihtml_open_uri(html, location);

1417

1418

if (selfp->has_toc)

1419

booktree_select_uri(BOOKTREE (selfp->booktree), location);

1420

} else {

1421

chmsee_ihtml_clear(html);

1422

}

1423

1424

gtk_notebook_set_current_page(GTK_NOTEBOOK (selfp->html_notebook), num);

1425

}

1426

1427

static void

1428

open_homepage(ChmSee *self)

1429

{

1430

ChmseeIhtml *html;

1431

1432

html = get_active_html(self);

1433

1434

g_signal_handlers_block_by_func(html, html_open_uri_cb, self);

1435

1436

chmsee_ihtml_open_uri(html, g_build_filename(chmsee_ichmfile_get_dir(selfp->book),

1437

chmsee_ichmfile_get_home(selfp->book), NULL));

1438

1439

g_signal_handlers_unblock_by_func(html, html_open_uri_cb, self);

1440

1441

if (selfp->has_toc) {

1442

booktree_select_uri(BOOKTREE (selfp->booktree),

1443

chmsee_ichmfile_get_home(selfp->book));

1444

}

1445

1446

check_history(self, html);

1447

}

1448

1449

static void

1450

reload_current_page(ChmSee *self)

1451

{

1452

ChmseeIhtml*html;

1453

const gchar *location;

1348

1454

1349

1455

g_message("Reload current page");

1350

1456

1351

g_return_if_fail(GTK_IS_NOTEBOOK (chmsee->html_notebook));

1352

1353

html = get_active_html(chmsee);

1354

location = html_get_location(html);

1355

1356

if (location != NULL)

1357

html_open_uri(html, location);

1358

1359

g_free(location);

1457

g_return_if_fail(GTK_IS_NOTEBOOK (selfp->html_notebook));

1458

1459

html = get_active_html(self);

1460

location = chmsee_ihtml_get_location(html);

1461

1462

if (location != NULL) {

1463

chmsee_ihtml_open_uri(html, location);

1464

}

1360

1465

}

1361

1466

1362

static Html *

1363

get_active_html(ChmSee *chmsee)

1467

static ChmseeIhtml *

1468

get_active_html(ChmSee *self)

1364

1469

{

1365

1470

GtkWidget *frame;

1366

1471

gint page_num;

1367

1472

1368

page_num = gtk_notebook_get_current_page(GTK_NOTEBOOK (chmsee->html_notebook));

1473

if(!selfp->html_notebook) {

1474

return NULL;

1475

}

1476

page_num = gtk_notebook_get_current_page(GTK_NOTEBOOK (selfp->html_notebook));

1369

1477

1370

1478

if (page_num == -1)

1371

1479

return NULL;

1372

1480

1373

frame = gtk_notebook_get_nth_page(GTK_NOTEBOOK (chmsee->html_notebook), page_num);

1481

frame = gtk_notebook_get_nth_page(GTK_NOTEBOOK (selfp->html_notebook), page_num);

1374

1482

1375

1483

return g_object_get_data(G_OBJECT (frame), "html");

1376

1484

}

1377

1485

1378

1486

static void

1379

check_history(ChmSee *chmsee, Html *html)

1487

check_history(ChmSee *chmsee, ChmseeIhtml *html)

1380

1488

{

1381

1489

GtkWidget *menu_item, *toolbar_button;

1382

1490

gboolean back_state, forward_state;

1383

1491

1384

back_state = html_can_go_back(html);

1385

forward_state = html_can_go_forward(html);

1492

back_state = chmsee_ihtml_can_go_back(html);

1493

forward_state = chmsee_ihtml_can_go_forward(html);

1386

1494

1387

1495

menu_item = get_widget(chmsee, "menu_back");

1388

1496

gtk_widget_set_sensitive(menu_item, back_state);

1396

1504

}

1397

1505

1398

1506

static void

1399

update_tab_title(ChmSee *chmsee, Html *html)

1507

update_tab_title(ChmSee *self, ChmseeIhtml *html)

1400

1508

{

1401

gchar *html_title, *tab_title;

1402

const gchar *book_title;

1403

1404

html_title = html_get_title(html);

1405

1406

if (chmsee->has_toc)

1407

book_title = booktree_get_selected_book_title(BOOKTREE (chmsee->booktree));

1408

else

1509

const gchar* html_title;

1510

const gchar* tab_title;

1511

const gchar* book_title;

1512

1513

html_title = chmsee_ihtml_get_title(html);

1514

1515

if (selfp->has_toc)

1516

book_title = booktree_get_selected_book_title(BOOKTREE (selfp->booktree));

1517

else

1409

1518

book_title = "";

1410

1519

1411

1520

if (book_title && book_title[0] != '\0' &&

1419

1528

else

1420

1529

tab_title = g_strdup("");

1421

1530

1422

tab_set_title(chmsee, html, tab_title);

1423

1424

g_free(html_title);

1425

g_free(tab_title);

1531

tab_set_title(self, html, tab_title);

1426

1532

}

1427

1533

1428

1534

static void

1429

tab_set_title(ChmSee *chmsee, Html *html, const gchar *title)

1535

tab_set_title(ChmSee *self, ChmseeIhtml *html, const gchar *title)

1430

1536

{

1431

1537

GtkWidget *view;

1432

1538

GtkWidget *page;

1433

1539

GtkWidget *widget, *label;

1434

1540

gint num_pages, i;

1435

1541

1436

view = html_get_widget(html);

1542

view = chmsee_ihtml_get_widget(html);

1437

1543

1438

1544

if (title == NULL || title[0] == '\0')

1439

1545

title = _("No Title");

1440

1546

1441

num_pages = gtk_notebook_get_n_pages(GTK_NOTEBOOK (chmsee->html_notebook));

1547

num_pages = gtk_notebook_get_n_pages(GTK_NOTEBOOK (selfp->html_notebook));

1442

1548

1443

1549

for (i = 0; i < num_pages; i++) {

1444

page = gtk_notebook_get_nth_page(GTK_NOTEBOOK (chmsee->html_notebook), i);

1550

page = gtk_notebook_get_nth_page(GTK_NOTEBOOK (selfp->html_notebook), i);

1445

1551

1446

1552

if (gtk_bin_get_child(GTK_BIN (page)) == view) {

1447

widget = gtk_notebook_get_tab_label(GTK_NOTEBOOK (chmsee->html_notebook), page);

1553

widget = gtk_notebook_get_tab_label(GTK_NOTEBOOK (selfp->html_notebook), page);

1448

1554

1449

1555

label = g_object_get_data(G_OBJECT (widget), "label");

1450

1556

1457

1563

}

1458

1564

1459

1565

static void

1460

update_status_bar(ChmSee *chmsee, const gchar *message)

1566

update_status_bar(ChmSee *self, const gchar *message)

1461

1567

{

1462

1568

gchar *status;

1463

1569

1464

1570

status = g_strdup_printf(" %s", message);

1465

1571

1466

gtk_statusbar_pop(GTK_STATUSBAR(chmsee->statusbar), chmsee->scid_default);

1467

gtk_statusbar_push(GTK_STATUSBAR(chmsee->statusbar), chmsee->scid_default, status);

1572

gtk_statusbar_pop(GTK_STATUSBAR(selfp->statusbar), selfp->scid_default);

1573

gtk_statusbar_push(GTK_STATUSBAR(selfp->statusbar), selfp->scid_default, status);

1468

1574

1469

1575

g_free(status);

1470

1576

}

1472

1578

/* external functions */

1473

1579

1474

1580

ChmSee *

1475

chmsee_new(void)

1581

chmsee_new(const gchar* filename)

1476

1582

{

1477

ChmSee *chmsee;

1583

ChmSee *self;

1478

1584

1479

chmsee = g_object_new(TYPE_CHMSEE, NULL);

1585

self = g_object_new(TYPE_CHMSEE, NULL);

1480

1586

1481

1587

/* Quit event handle */

1482

g_signal_connect(G_OBJECT (chmsee),

1588

g_signal_connect(G_OBJECT (self),

1483

1589

"delete_event",

1484

1590

G_CALLBACK (delete_cb),

1485

chmsee);

1486

g_signal_connect(G_OBJECT (chmsee),

1591

self);

1592

g_signal_connect(G_OBJECT (self),

1487

1593

"destroy",

1488

1594

G_CALLBACK (destroy_cb),

1489

chmsee);

1595

self);

1490

1596

1491

1597

/* Widget size changed event handle */

1492

g_signal_connect(G_OBJECT (chmsee),

1598

g_signal_connect(G_OBJECT (self),

1493

1599

"configure-event",

1494

G_CALLBACK (configure_event_cb),

1495

chmsee);

1496

1497

load_chmsee_config(chmsee);

1600

G_CALLBACK (on_configure_event),

1601

self);

1498

1602

1499

1603

/* Init gecko */

1500

html_init_system();

1501

html_set_default_lang(chmsee->lang);

1502

1503

window_populate(chmsee);

1504

1505

if (chmsee->pos_x >= 0 && chmsee->pos_y >= 0)

1506

gtk_window_move(GTK_WINDOW (chmsee), chmsee->pos_x, chmsee->pos_y);

1507

1508

if (chmsee->width > 0 && chmsee->height > 0)

1509

gtk_window_resize(GTK_WINDOW (chmsee), chmsee->width, chmsee->height);

1604

chmsee_html_init_system();

1605

chmsee_html_set_default_lang(selfp->lang);

1606

1607

populate_window(self);

1608

chmsee_load_config(self);

1609

if (selfp->pos_x >= 0 && selfp->pos_y >= 0)

1610

gtk_window_move(GTK_WINDOW (self), selfp->pos_x, selfp->pos_y);

1611

1612

if (selfp->width > 0 && selfp->height > 0)

1613

gtk_window_resize(GTK_WINDOW (self), selfp->width, selfp->height);

1510

1614

else

1511

gtk_window_resize(GTK_WINDOW (chmsee), 800, 600);

1512

1513

gtk_window_set_title(GTK_WINDOW (chmsee), "ChmSee");

1514

gtk_window_set_icon_from_file(GTK_WINDOW (chmsee), CHMSEE_DATA_DIR"/chmsee-icon.png", NULL);

1515

1516

return chmsee;

1615

gtk_window_resize(GTK_WINDOW (self), 800, 600);

1616

1617

gtk_window_set_title(GTK_WINDOW (self), "ChmSee");

1618

gtk_window_set_icon_from_file(GTK_WINDOW (self), get_resource_path("chmsee-icon.png"), NULL);

1619

1620

if(filename != NULL) {

1621

chmsee_open_file(self, filename);

1622

}

1623

1624

return self;

1517

1625

}

1518

1626

1519

1627

void

1520

chmsee_open_file(ChmSee *chmsee, const gchar *filename)

1628

chmsee_open_file(ChmSee *self, const gchar *filename)

1521

1629

{

1522

ChmFile *book;

1630

ChmseeIchmfile* book;

1523

1631

1524

g_return_if_fail(IS_CHMSEE (chmsee));

1632

g_return_if_fail(IS_CHMSEE (self));

1525

1633

1526

1634

/* Extract chm and get file infomation */

1527

book = chmfile_new(filename);

1635

book = chmsee_chmfile_new(filename);

1528

1636

1529

1637

if (book) {

1530

display_book(chmsee, book);

1638

display_book(self, book);

1531

1639

1532

chmsee->last_dir = g_strdup_printf("%s", g_path_get_dirname(filename));

1640

selfp->last_dir = g_strdup_printf("%s", g_path_get_dirname(filename));

1533

1641

} else {

1534

1642

/* Popup an error message dialog */

1535

1643

GtkWidget *msg_dialog;

1536

1537

msg_dialog = gtk_message_dialog_new(GTK_WINDOW (chmsee),

1644

1645

msg_dialog = gtk_message_dialog_new(GTK_WINDOW (self),

1538

1646

GTK_DIALOG_DESTROY_WITH_PARENT,

1539

1647

GTK_MESSAGE_ERROR,

1540

1648

GTK_BUTTONS_CLOSE,

1587

1695

chmsee_open_file(chmsee, fname);

1588

1696

g_free(fname);

1589

1697

}

1698

1699

int chmsee_get_hpaned_position(ChmSee* self) {

1700

gint position;

1701

g_object_get(G_OBJECT(get_widget(self, "hpaned1")),

1702

"position", &position,

1703

NULL

1704

);

1705

return position;

1706

}

1707

1708

void chmsee_set_hpaned_position(ChmSee* self, int hpaned_position) {

1709

selfp->hpaned_position = hpaned_position;

1710

/*

1711

g_object_set(G_OBJECT(get_widget(self, "hpaned1")),

1712

"position", hpaned_position,

1713

NULL

1714

);

1715

*/

1716

}

1717

1718

void on_fullscreen_toggled(ChmSee* self, GtkWidget* menu) {

1719

g_return_if_fail(IS_CHMSEE(self));

1720

gboolean active;

1721

g_object_get(G_OBJECT(menu),

1722

"active", &active,

1723

NULL);

1724

chmsee_set_fullscreen(self, active);

1725

}

1726

1727

void on_sidepane_toggled(ChmSee* self, GtkWidget* menu) {

1728

g_return_if_fail(IS_CHMSEE(self));

1729

gboolean active;

1730

g_object_get(G_OBJECT(menu),

1731

"active", &active,

1732

NULL);

1733

if(active) {

1734

show_sidepane(self);

1735

} else {

1736

hide_sidepane(self);

1737

}

1738

}

1739

1740

void set_sidepane_state(ChmSee* self, gboolean state) {

1741

GtkWidget* icon_widget;

1742

1743

if(state) {

1744

gtk_widget_show(get_widget(self, "control_vbox"));

1745

} else {

1746

gtk_widget_hide(get_widget(self, "control_vbox"));

1747

}

1748

1749

gboolean menu_state = gtk_check_menu_item_get_active(

1750

GTK_CHECK_MENU_ITEM(get_widget(self, "menu_sidepane")));

1751

if(menu_state != state) {

1752

gtk_check_menu_item_set_active(

1753

GTK_CHECK_MENU_ITEM(get_widget(self, "menu_sidepane")), state);

1754

}

1755

1756

gboolean toolbar_state = gtk_toggle_tool_button_get_active(

1757

GTK_TOGGLE_TOOL_BUTTON(get_widget(self, "toolbar_hpanes")));

1758

if(toolbar_state != state) {

1759

gtk_toggle_tool_button_set_active(

1760

GTK_TOGGLE_TOOL_BUTTON(get_widget(self, "toolbar_hpanes")), state);

1761

}

1762

1763

if (state) {

1764

icon_widget = gtk_image_new_from_file(get_resource_path("hide-pane.png"));

1765

} else {

1766

icon_widget = gtk_image_new_from_file(get_resource_path("show-pane.png"));

1767

}

1768

gtk_widget_show(icon_widget);

1769

gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON (get_widget(self, "toolbar_hpanes")), icon_widget);

1770

};

1771

1772

void show_sidepane(ChmSee* self) {

1773

set_sidepane_state(self, TRUE);

1774

}

1775

1776

void hide_sidepane(ChmSee* self) {

1777

set_sidepane_state(self, FALSE);

1778

}

1779

1780

1781

void on_map(ChmSee* self) {

1782

if(selfp->hpaned_position >= 0) {

1783

g_object_set(G_OBJECT(get_widget(self, "hpaned1")),

1784

"position", selfp->hpaned_position,

1785

NULL

1786

);

1787

}

1788

}

1789

1790

1791

static void on_fullscreen(ChmSee* self) {

1792

gtk_widget_hide(get_widget(self, "handlebox_menu"));

1793

gtk_widget_hide(get_widget(self, "handlebox_toolbar"));

1794

gtk_widget_hide(get_widget(self, "statusbar"));

1795

gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(get_widget(self, "menu_fullscreen")),

1796

TRUE);

1797

selfp->fullscreen = TRUE;

1798

}

1799

1800

static void on_unfullscreen(ChmSee* self) {

1801

gtk_widget_show(get_widget(self, "handlebox_menu"));

1802

gtk_widget_show(get_widget(self, "handlebox_toolbar"));

1803

gtk_widget_show(get_widget(self, "statusbar"));

1804

gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(get_widget(self, "menu_fullscreen")),

1805

FALSE);

1806

selfp->fullscreen = FALSE;

1807

}

1808

1809

gboolean on_window_state_event(ChmSee* self, GdkEventWindowState* event) {

1810

g_return_val_if_fail(IS_CHMSEE(self), FALSE);

1811

g_return_val_if_fail(event->type == GDK_WINDOW_STATE, FALSE);

1812

1813

if(!(event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN)) {

1814

return FALSE;

1815

}

1816

1817

if(event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) {

1818

on_fullscreen(self);

1819

} else {

1820

on_unfullscreen(self);

1821

}

1822

1823

return FALSE;

1824

}

1825

1826

static gboolean on_scroll_event(ChmSee* self, GdkEventScroll* event) {

1827

if(event->direction == GDK_SCROLL_UP && (event->state & GDK_CONTROL_MASK)) {

1828

on_zoom_in(NULL, self);

1829

return TRUE;

1830

} else if(event->direction == GDK_SCROLL_DOWN && (event->state & GDK_CONTROL_MASK)) {

1831

on_zoom_out(NULL, self);

1832

return TRUE;

1833

} else {

1834

g_debug("event->direction: %d", event->direction);

1835

g_debug("event->state: %x", event->state);

1836

}

1837

1838

return FALSE;

1839

}

1840

1841

const gchar* chmsee_get_cache_dir(ChmSee* self) {

1842

return selfp->cache_dir;

1843

}

1844

1845

const gchar* chmsee_get_variable_font(ChmSee* self) {

1846

g_return_val_if_fail(selfp->book, NULL);

1847

return chmsee_ichmfile_get_variable_font(selfp->book);

1848

}

1849

1850

void chmsee_set_variable_font(ChmSee* self, const gchar* font_name) {

1851

g_return_if_fail(selfp->book);

1852

chmsee_ichmfile_set_variable_font(selfp->book, font_name);

1853

}

1854

1855

const gchar* chmsee_get_fixed_font(ChmSee* self) {

1856

g_return_val_if_fail(selfp->book, NULL);

1857

return chmsee_ichmfile_get_fixed_font(selfp->book);

1858

}

1859

1860

void chmsee_set_fixed_font(ChmSee* self, const gchar* font_name) {

1861

g_return_if_fail(selfp->book);

1862

chmsee_ichmfile_set_fixed_font(selfp->book, font_name);

1863

}

1864

1865

int chmsee_get_lang(ChmSee* self) {

1866

return selfp->lang;

1867

}

1868

void chmsee_set_lang(ChmSee* self, int lang) {

1869

selfp->lang = lang;

1870

}

1871

1872

gboolean chmsee_has_book(ChmSee* self) {

1873

return selfp->book != NULL;

1874

}

1875

1876

void

1877

chmsee_load_config(ChmSee *self)

1878

{

1879

GList *pairs, *list;

1880

gchar *path;

1881

1882

path = g_build_filename(selfp->home, "config", NULL);

1883

1884

g_debug("config path = %s", path);

1885

1886

pairs = parse_config_file("config", path);

1887

1888

for (list = pairs; list; list = list->next) {

1889

Item *item;

1890

1891

item = list->data;

1892

1893

/* Get user prefered language */

1894

if (strstr(item->id, "LANG")) {

1895

selfp->lang = atoi(item->value);

1896

continue;

1897

}

1898

1899

/* Get last directory */

1900

if (strstr(item->id, "LAST_DIR")) {

1901

selfp->last_dir = g_strdup(item->value);

1902

continue;

1903

}

1904

1905

/* Get window position */

1906

if (strstr(item->id, "POS_X")) {

1907

selfp->pos_x = atoi(item->value);

1908

continue;

1909

}

1910

if (strstr(item->id, "POS_Y")) {

1911

selfp->pos_y = atoi(item->value);

1912

continue;

1913

}

1914

if (strstr(item->id, "WIDTH")) {

1915

selfp->width = atoi(item->value);

1916

continue;

1917

}

1918

if (strstr(item->id, "HEIGHT")) {

1919

selfp->height = atoi(item->value);

1920

continue;

1921

}

1922

if(strstr(item->id, "HPANED_POSTION")) {

1923

chmsee_set_hpaned_position(self, atoi(item->value));

1924

continue;

1925

}

1926

if(strstr(item->id, "FULLSCREEN")) {

1927

if(strcmp(item->value, "true") == 0) {

1928

chmsee_set_fullscreen(self, TRUE);

1929

} else if(strcmp(item->value, "false") == 0) {

1930

chmsee_set_fullscreen(self, FALSE);

1931

} else {

1932

g_warning("%s:%d:unknown value of FULLSCREEN %s", __FILE__, __LINE__, item->value);

1933

}

1934

}

1935

}

1936

1937

free_config_list(pairs);

1938

g_free(path);

1939

}

1940

1941

void

1942

chmsee_save_config(ChmSee *self)

1943

{

1944

FILE *file;

1945

gchar *path;

1946

1947

path = g_build_filename(selfp->home, "config", NULL);

1948

1949

file = fopen(path, "w");

1950

1951

if (!file) {

1952

g_print("Faild to open chmsee config: %s", path);

1953

return;

1954

}

1955

1956

save_option(file, "LANG", g_strdup_printf("%d", selfp->lang));

1957

save_option(file, "LAST_DIR", selfp->last_dir);

1958

save_option(file, "POS_X", g_strdup_printf("%d", selfp->pos_x));

1959

save_option(file, "POS_Y", g_strdup_printf("%d", selfp->pos_y));

1960

save_option(file, "WIDTH", g_strdup_printf("%d", selfp->width));

1961

save_option(file, "HEIGHT", g_strdup_printf("%d", selfp->height));

1962

save_option(file, "HPANED_POSTION", g_strdup_printf("%d", chmsee_get_hpaned_position(self)));

1963

save_option(file, "FULLSCREEN", selfp->fullscreen ? "true" : "false" );

1964

1965

fclose(file);

1966

g_free(path);

1967

}

1968

1969

void chmsee_set_fullscreen(ChmSee* self, gboolean fullscreen) {

1970

if(fullscreen == selfp->fullscreen) {

1971

return;

1972

}

1973

1974

if(fullscreen) {

1975

gtk_window_fullscreen(GTK_WINDOW(self));

1976

} else {

1977

gtk_window_unfullscreen(GTK_WINDOW(self));

1978

}

1979

}