~cairo-dock-team/ubuntu/oneiric/cairo-dock/2.3.0-3

gtk_list_store_new (CAIRO_DOCK_MODEL_NB_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_INT, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_INT, G_TYPE_INT)

static void _cairo_dock_activate_one_element (GtkCellRendererToggle * cell_renderer, gchar * path, GtkTreeModel * model)

{

GtkTreeIter iter;

if (! gtk_tree_model_get_iter_from_string (model, &iter, path))

return ;

gboolean bState;

gtk_tree_model_get (model, &iter, CAIRO_DOCK_MODEL_ACTIVE, &bState, -1);

gtk_list_store_set (GTK_LIST_STORE (model), &iter, CAIRO_DOCK_MODEL_ACTIVE, !bState, -1);

}

static gboolean _cairo_dock_increase_order (GtkTreeModel * model, GtkTreePath * path, GtkTreeIter * iter, int *pOrder)

{

int iMyOrder;

gtk_tree_model_get (model, iter, CAIRO_DOCK_MODEL_ORDER, &iMyOrder, -1);

if (iMyOrder == *pOrder)

{

gtk_list_store_set (GTK_LIST_STORE (model), iter, CAIRO_DOCK_MODEL_ORDER, iMyOrder + 1, -1);

return TRUE;

}

return FALSE;

}

static gboolean _cairo_dock_decrease_order (GtkTreeModel * model, GtkTreePath * path, GtkTreeIter * iter, int *pOrder)

{

int iMyOrder;

gtk_tree_model_get (model, iter, CAIRO_DOCK_MODEL_ORDER, &iMyOrder, -1);

if (iMyOrder == *pOrder)

100

{

101

gtk_list_store_set (GTK_LIST_STORE (model), iter, CAIRO_DOCK_MODEL_ORDER, iMyOrder - 1, -1);

102

return TRUE;

103

}

104

return FALSE;

105

}

106

107

static gboolean _cairo_dock_decrease_order_if_greater (GtkTreeModel * model, GtkTreePath * path, GtkTreeIter * iter, int *pOrder)

108

{

109

int iMyOrder;

110

gtk_tree_model_get (model, iter, CAIRO_DOCK_MODEL_ORDER, &iMyOrder, -1);

111

112

if (iMyOrder > *pOrder)

113

{

114

gtk_list_store_set (GTK_LIST_STORE (model), iter, CAIRO_DOCK_MODEL_ORDER, iMyOrder - 1, -1);

115

return TRUE;

116

}

117

return FALSE;

118

}

119

120

static void _cairo_dock_go_up (GtkButton *button, GtkTreeView *pTreeView)

121

{

122

GtkTreeSelection *pSelection = gtk_tree_view_get_selection (pTreeView);

123

124

GtkTreeModel *pModel;

125

GtkTreeIter iter;

126

if (! gtk_tree_selection_get_selected (pSelection, &pModel, &iter))

127

return ;

128

129

int iOrder;

130

gtk_tree_model_get (pModel, &iter, CAIRO_DOCK_MODEL_ORDER, &iOrder, -1);

131

iOrder --;

132

if (iOrder < 0)

133

return;

134

135

gtk_tree_model_foreach (GTK_TREE_MODEL (pModel), (GtkTreeModelForeachFunc) _cairo_dock_increase_order, &iOrder);

136

137

gtk_list_store_set (GTK_LIST_STORE (pModel), &iter, CAIRO_DOCK_MODEL_ORDER, iOrder, -1);

138

}

139

140

static void _cairo_dock_go_down (GtkButton *button, GtkTreeView *pTreeView)

141

{

142

GtkTreeSelection *pSelection = gtk_tree_view_get_selection (pTreeView);

143

144

GtkTreeModel *pModel;

145

GtkTreeIter iter;

146

if (! gtk_tree_selection_get_selected (pSelection, &pModel, &iter))

147

return ;

148

149

int iOrder;

150

gtk_tree_model_get (pModel, &iter, CAIRO_DOCK_MODEL_ORDER, &iOrder, -1);

151

iOrder ++;

152

if (iOrder > gtk_tree_model_iter_n_children (pModel, NULL) - 1)

153

return;

154

155

gtk_tree_model_foreach (GTK_TREE_MODEL (pModel), (GtkTreeModelForeachFunc) _cairo_dock_decrease_order, &iOrder);

156

157

gtk_list_store_set (GTK_LIST_STORE (pModel), &iter, CAIRO_DOCK_MODEL_ORDER, iOrder, -1);

158

}

159

160

static void _cairo_dock_add (GtkButton *button, gpointer *data)

161

{

162

GtkTreeView *pTreeView = data[0];

163

GtkWidget *pEntry = data[1];

164

165

GtkTreeIter iter;

166

memset (&iter, 0, sizeof (GtkTreeIter));

167

168

GtkTreeModel *pModel = gtk_tree_view_get_model (pTreeView);

169

gtk_list_store_append (GTK_LIST_STORE (pModel), &iter);

170

171

gtk_list_store_set (GTK_LIST_STORE (pModel), &iter,

172

CAIRO_DOCK_MODEL_ACTIVE, TRUE,

173

CAIRO_DOCK_MODEL_NAME, gtk_entry_get_text (GTK_ENTRY (pEntry)),

174

CAIRO_DOCK_MODEL_ORDER, gtk_tree_model_iter_n_children (pModel, NULL) - 1, -1);

175

176

GtkTreeSelection *pSelection = gtk_tree_view_get_selection (pTreeView);

177

gtk_tree_selection_select_iter (pSelection, &iter);

178

}

179

180

static void _cairo_dock_remove (GtkButton *button, gpointer *data)

181

{

182

GtkTreeView *pTreeView = data[0];

183

GtkWidget *pEntry = data[1];

184

185

GtkTreeSelection *pSelection = gtk_tree_view_get_selection (pTreeView);

186

GtkTreeModel *pModel;

187

188

GtkTreeIter iter;

189

if (! gtk_tree_selection_get_selected (pSelection, &pModel, &iter))

190

return ;

191

192

gchar *cValue = NULL;

193

int iOrder;

194

gtk_tree_model_get (pModel, &iter,

195

CAIRO_DOCK_MODEL_NAME, &cValue,

196

CAIRO_DOCK_MODEL_ORDER, &iOrder, -1);

197

198

gtk_list_store_remove (GTK_LIST_STORE (pModel), &iter);

199

gtk_tree_model_foreach (GTK_TREE_MODEL (pModel), (GtkTreeModelForeachFunc) _cairo_dock_decrease_order_if_greater, &iOrder);

200

201

gtk_entry_set_text (GTK_ENTRY (pEntry), cValue);

202

g_free (cValue);

203

}

204

205

static gboolean on_delete_async_widget (GtkWidget *pMainWindow, GdkEvent *event, GtkWidget *pWidget)

206

{

207

//g_print ("%s ()\n", __func__);

208

CairoDockTask *pTask = g_object_get_data (G_OBJECT (pWidget), "cd-task");

209

if (pTask != NULL)

210

{

211

cairo_dock_discard_task (pTask);

212

g_object_set_data (G_OBJECT (pWidget), "cd-task", NULL);

213

}

214

g_object_unref (G_OBJECT (pWidget));

215

return FALSE;

216

}

217

218

static inline void _set_preview_image (const gchar *cPreviewFilePath, GtkImage *pPreviewImage)

219

{

220

int iPreviewWidth, iPreviewHeight;

221

GdkPixbuf *pPreviewPixbuf = NULL;

222

if (gdk_pixbuf_get_file_info (cPreviewFilePath, &iPreviewWidth, &iPreviewHeight) != NULL)

223

{

224

iPreviewWidth = MIN (iPreviewWidth, CAIRO_DOCK_PREVIEW_WIDTH);

225

iPreviewHeight = MIN (iPreviewHeight, CAIRO_DOCK_PREVIEW_HEIGHT);

226

g_print ("preview : %dx%d\n", iPreviewWidth, iPreviewHeight); //

227

pPreviewPixbuf = gdk_pixbuf_new_from_file_at_size (cPreviewFilePath, iPreviewWidth, iPreviewHeight, NULL);

228

}

229

if (pPreviewPixbuf == NULL)

230

{

231

pPreviewPixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,

232

TRUE,

233

234

235

1);

236

}

237

gtk_image_set_from_pixbuf (pPreviewImage, pPreviewPixbuf);

238

gdk_pixbuf_unref (pPreviewPixbuf);

239

}

240

241

static void _on_got_readme (const gchar *cDescription, GtkWidget *pDescriptionLabel)

242

{

243

//g_print ("%s ()\n", __func__);

244

gtk_label_set_markup (GTK_LABEL (pDescriptionLabel), cDescription ? cDescription : "");

245

246

CairoDockTask *pTask = g_object_get_data (G_OBJECT (pDescriptionLabel), "cd-task");

247

if (pTask != NULL)

248

{

249

//g_print ("remove the task\n");

250

cairo_dock_discard_task (pTask);

251

g_object_set_data (G_OBJECT (pDescriptionLabel), "cd-task", NULL);

252

}

253

}

254

static void _on_got_preview_file (const gchar *cPreviewFilePath, GtkWidget *pPreviewImage)

255

{

256

if (cPreviewFilePath != NULL)

257

{

258

_set_preview_image (cPreviewFilePath, GTK_IMAGE (pPreviewImage));

259

g_remove (cPreviewFilePath);

260

}

261

CairoDockTask *pTask = g_object_get_data (G_OBJECT (pPreviewImage), "cd-task");

262

if (pTask != NULL)

263

{

264

cairo_dock_discard_task (pTask);

265

g_object_set_data (G_OBJECT (pPreviewImage), "cd-task", NULL);

266

}

267

}

268

static void _cairo_dock_selection_changed (GtkTreeModel *model, GtkTreeIter iter, gpointer *data)

269

{

270

static gchar *s_cPrevPreview = NULL, *s_cPrevReadme = NULL;

271

GtkLabel *pDescriptionLabel = data[0];

272

gtk_label_set_justify (GTK_LABEL (pDescriptionLabel), GTK_JUSTIFY_FILL);

273

gtk_label_set_line_wrap (pDescriptionLabel, TRUE);

274

GtkImage *pPreviewImage = data[1];

275

GError *erreur = NULL;

276

gchar *cDescriptionFilePath = NULL, *cPreviewFilePath = NULL, *cName = NULL;

277

gtk_tree_model_get (model, &iter,

278

CAIRO_DOCK_MODEL_DESCRIPTION_FILE, &cDescriptionFilePath,

279

CAIRO_DOCK_MODEL_IMAGE, &cPreviewFilePath, -1);

280

281

if (cDescriptionFilePath != NULL && (1 || !s_cPrevReadme || strcmp (s_cPrevReadme, cDescriptionFilePath) != 0))

282

{

283

CairoDockTask *pTask = g_object_get_data (G_OBJECT (pDescriptionLabel), "cd-task");

284

//g_print ("prev task : %x\n", pTask);

285

if (pTask != NULL)

286

{

287

cairo_dock_discard_task (pTask);

288

g_object_set_data (G_OBJECT (pDescriptionLabel), "cd-task", NULL);

289

}

290

g_free (s_cPrevReadme);

291

s_cPrevReadme = g_strdup (cDescriptionFilePath);

292

if (strncmp (cDescriptionFilePath, "http://", 7) == 0) // fichier distant.

293

{

294

cd_debug ("fichier readme distant (%s)", cDescriptionFilePath);

295

296

gchar *str = strrchr (cDescriptionFilePath, '/');

297

g_return_if_fail (str != NULL);

298

*str = '\0';

299

300

gtk_label_set_markup (pDescriptionLabel, "...");

301

pTask = cairo_dock_get_distant_file_content_async (cDescriptionFilePath, "", str+1, (GFunc) _on_got_readme, pDescriptionLabel);

302

g_object_set_data (G_OBJECT (pDescriptionLabel), "cd-task", pTask);

303

//g_print ("new task : %x\n", pTask);

304

}

305

else if (*cDescriptionFilePath == '/') // fichier local

306

{

307

gsize length = 0;

308

gchar *cDescription = NULL;

309

g_file_get_contents (cDescriptionFilePath,

310

&cDescription,

311

&length,

312

NULL);

313

gtk_label_set_markup (pDescriptionLabel, cDescription ? cDescription : "");

314

g_free (cDescription);

315

}

316

else if (strcmp (cDescriptionFilePath, "none") != 0) // texte de la description.

317

{

318

gtk_label_set_markup (pDescriptionLabel, cDescriptionFilePath);

319

}

320

else // rien.

321

gtk_label_set_markup (pDescriptionLabel, "");

322

}

323

324

if (cPreviewFilePath != NULL && (1 || !s_cPrevPreview || strcmp (s_cPrevPreview, cPreviewFilePath) != 0))

325

{

326

g_free (s_cPrevPreview);

327

s_cPrevPreview = g_strdup (cPreviewFilePath);

328

329

gboolean bDistant = FALSE;

330

if (strncmp (cPreviewFilePath, "http://", 7) == 0) // fichier distant.

331

{

332

cd_debug ("fichier preview distant (%s)", cPreviewFilePath);

333

334

gchar *str = strrchr (cPreviewFilePath, '/');

335

g_return_if_fail (str != NULL);

336

*str = '\0';

337

338

CairoDockTask *pTask = g_object_get_data (G_OBJECT (pPreviewImage), "cd-task");

339

if (pTask != NULL)

340

cairo_dock_discard_task (pTask);

341

342

pTask = cairo_dock_download_file_async (cPreviewFilePath, "", str+1, NULL, (GFunc) _on_got_preview_file, pPreviewImage);

343

g_object_set_data (G_OBJECT (pPreviewImage), "cd-task", pTask);

344

}

345

else // fichier local ou rien.

346

_set_preview_image (cPreviewFilePath, pPreviewImage);

347

}

348

349

g_free (cDescriptionFilePath);

350

g_free (cPreviewFilePath);

351

}

352

353

static void _cairo_dock_select_custom_item_in_combo (GtkComboBox *widget, gpointer *data)

354

{

355

GtkTreeModel *model = gtk_combo_box_get_model (widget);

356

g_return_if_fail (model != NULL);

357

358

GtkTreeIter iter;

359

if (!gtk_combo_box_get_active_iter (widget, &iter))

360

return ;

361

362

GtkWidget *parent = data[1];

363

GtkWidget *pKeyBox = data[0];

364

int iNbWidgets = GPOINTER_TO_INT (data[2]);

365

GList *children = gtk_container_get_children (GTK_CONTAINER (parent));

366

GList *c = g_list_find (children, pKeyBox);

367

g_return_if_fail (c != NULL && c->next != NULL);

368

369

gchar *cName = NULL;

370

gtk_tree_model_get (model, &iter,

371

CAIRO_DOCK_MODEL_RESULT, &cName, -1);

372

373

gboolean bActive = (cName != NULL && strcmp (cName, "personnal") == 0);

374

GtkWidget *w;

375

int i;

376

for (c = c->next, i = 0; c != NULL && i < iNbWidgets; c = c->next, i ++)

377

{

378

w = c->data;

379

gtk_widget_set_sensitive (w, bActive);

380

}

381

382

g_list_free (children);

383

g_free (cName);

384

}

385

386

static void _cairo_dock_select_one_item_in_combo (GtkComboBox *widget, gpointer *data)

387

{

388

GtkTreeModel *model = gtk_combo_box_get_model (widget);

389

g_return_if_fail (model != NULL);

390

391

GtkTreeIter iter;

392

if (!gtk_combo_box_get_active_iter (widget, &iter))

393

return ;

394

395

_cairo_dock_selection_changed (model, iter, data);

396

}

397

398

static gboolean _cairo_dock_select_one_item_in_tree (GtkTreeSelection * selection, GtkTreeModel * model, GtkTreePath * path, gboolean path_currently_selected, gpointer *data)

399

{

400

if (path_currently_selected)

401

return TRUE;

402

GtkTreeIter iter;

403

if (! gtk_tree_model_get_iter (model, &iter, path))

404

return FALSE;

405

406

_cairo_dock_selection_changed (model, iter, data);

407

return TRUE;

408

}

409

410

static void _cairo_dock_select_one_item_in_control_combo (GtkComboBox *widget, gpointer *data)

411

{

412

GtkTreeModel *model = gtk_combo_box_get_model (widget);

413

g_return_if_fail (model != NULL);

414

415

GtkTreeIter iter;

416

if (!gtk_combo_box_get_active_iter (widget, &iter))

417

return ;

418

419

int iNumItem = gtk_combo_box_get_active (widget);

420

//gtk_tree_model_get (model, &iter, CAIRO_DOCK_MODEL_ORDER, &iNumItem, -1);

421

422

GtkWidget *parent = data[1];

423

GtkWidget *pKeyBox = data[0];

424

int iNbWidgets = GPOINTER_TO_INT (data[2]);

425

GList *children = gtk_container_get_children (GTK_CONTAINER (parent));

426

GList *c = g_list_find (children, pKeyBox);

427

g_return_if_fail (c != NULL);

428

429

GtkWidget *w;

430

int i;

431

for (c = c->next, i = 0; c != NULL && i < iNbWidgets; c = c->next, i ++)

432

{

433

w = c->data;

434

//g_print (" %d/%d -> %d\n", i, iNbWidgets, i == iNumItem);

435

if (GTK_IS_EXPANDER (w))

436

{

437

gtk_expander_set_expanded (GTK_EXPANDER (w), i == iNumItem);

438

}

439

else

440

{

441

gtk_widget_set_sensitive (w, i == iNumItem);

442

}

443

}

444

445

g_list_free (children);

446

}

447

static void _cairo_dock_select_one_item_in_control_combo_selective (GtkComboBox *widget, gpointer *data)

448

{

449

GtkTreeModel *model = gtk_combo_box_get_model (widget);

450

g_return_if_fail (model != NULL);

451

452

GtkTreeIter iter;

453

if (!gtk_combo_box_get_active_iter (widget, &iter))

454

return ;

455

456

int iOrder1, iOrder2;

457

gtk_tree_model_get (model, &iter,

458

CAIRO_DOCK_MODEL_ORDER, &iOrder1,

459

CAIRO_DOCK_MODEL_ORDER2, &iOrder2, -1);

460

461

GtkWidget *parent = data[1];

462

GtkWidget *pKeyBox = data[0];

463

int iNbWidgets = GPOINTER_TO_INT (data[2]);

464

//g_print ("%s (%d, %d / %d)\n", __func__, iOrder1, iOrder2, iNbWidgets);

465

GList *children = gtk_container_get_children (GTK_CONTAINER (parent));

466

GList *c = g_list_find (children, pKeyBox);

467

g_return_if_fail (c != NULL);

468

469

GtkWidget *w;

470

int i;

471

for (c = c->next, i = 0; c != NULL && i < iNbWidgets; c = c->next, i ++)

472

{

473

w = c->data;

474

//g_print ("%d in ]%d;%d[\n", i, iOrder1, iOrder1 + iOrder2);

475

gtk_widget_set_sensitive (w, i >= iOrder1 - 1 && i < iOrder1 + iOrder2 - 1);

476

}

477

478

g_list_free (children);

479

}

480

481

static void _cairo_dock_show_image_preview (GtkFileChooser *pFileChooser, GtkImage *pPreviewImage)

482

{

483

gchar *cFileName = gtk_file_chooser_get_preview_filename (pFileChooser);

484

if (cFileName == NULL)

485

return ;

486

GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file_at_size (cFileName, 64, 64, NULL);

487

g_free (cFileName);

488

if (pixbuf != NULL)

489

{

490

gtk_image_set_from_pixbuf (pPreviewImage, pixbuf);

491

gdk_pixbuf_unref (pixbuf);

492

gtk_file_chooser_set_preview_widget_active (pFileChooser, TRUE);

493

}

494

else

495

gtk_file_chooser_set_preview_widget_active (pFileChooser, FALSE);

496

}

497

static void _cairo_dock_pick_a_file (GtkButton *button, gpointer *data)

498

{

499

GtkEntry *pEntry = data[0];

500

gint iFileType = GPOINTER_TO_INT (data[1]);

501

GtkWindow *pParentWindow = data[2];

502

503

GtkWidget* pFileChooserDialog = gtk_file_chooser_dialog_new (

504

(iFileType == 0 ? "Pick up a file" : "Pick up a directory"),

505

pParentWindow,

506

(iFileType == 0 ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER),

507

GTK_STOCK_OK,

508

GTK_RESPONSE_OK,

509

GTK_STOCK_CANCEL,

510

GTK_RESPONSE_CANCEL,

511

NULL);

512

const gchar *cFilePath = gtk_entry_get_text (pEntry);

513

gchar *cDirectoryPath = (cFilePath == NULL || *cFilePath != '/' ? g_strdup (g_cCurrentThemePath) : g_path_get_dirname (cFilePath));

514

//g_print (">>> on se place sur '%s'\n", cDirectoryPath);

515

gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (pFileChooserDialog), cDirectoryPath);

516

g_free (cDirectoryPath);

517

gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (pFileChooserDialog), FALSE);

518

519

GtkWidget *pPreviewImage = gtk_image_new ();

520

gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (pFileChooserDialog), pPreviewImage);

521

g_signal_connect (GTK_FILE_CHOOSER (pFileChooserDialog), "update-preview", G_CALLBACK (_cairo_dock_show_image_preview), pPreviewImage);

522

523

gtk_widget_show (pFileChooserDialog);

524

int answer = gtk_dialog_run (GTK_DIALOG (pFileChooserDialog));

525

if (answer == GTK_RESPONSE_OK)

526

{

527

gchar *cFilePath = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (pFileChooserDialog));

528

gtk_entry_set_text (pEntry, cFilePath);

529

}

530

gtk_widget_destroy (pFileChooserDialog);

531

}

532

533

//Sound Callback

534

static void _cairo_dock_play_a_sound (GtkButton *button, gpointer *data)

535

{

536

GtkWidget *pEntry = data[0];

537

const gchar *cSoundPath = gtk_entry_get_text (GTK_ENTRY (pEntry));

538

cairo_dock_play_sound (cSoundPath);

539

}

540

541

static void _cairo_dock_set_original_value (GtkButton *button, gpointer *data)

542

{

543

gchar *cGroupName = data[0];

544

gchar *cKeyName = data[1];

545

GSList *pSubWidgetList = data[2];

546

gchar *cOriginalConfFilePath = data[3];

547

//g_print ("%s (%s, %s, %s)\n", __func__, cGroupName, cKeyName, cOriginalConfFilePath);

548

549

GSList *pList;

550

gsize i = 0;

551

GtkWidget *pOneWidget = pSubWidgetList->data;

552

GError *erreur = NULL;

553

gsize length = 0;

554

555

GKeyFile *pKeyFile = g_key_file_new ();

556

g_key_file_load_from_file (pKeyFile, cOriginalConfFilePath, 0, &erreur); // inutile de garder les commentaires ce coup-ci.

557

if (erreur != NULL)

558

{

559

cd_warning (erreur->message);

560

g_error_free (erreur);

561

erreur = NULL;

562

return ;

563

}

564

565

if (GTK_IS_SPIN_BUTTON (pOneWidget) || GTK_IS_HSCALE (pOneWidget))

566

{

567

gboolean bIsSpin = GTK_IS_SPIN_BUTTON (pOneWidget);

568

double *fValuesList = g_key_file_get_double_list (pKeyFile, cGroupName, cKeyName, &length, &erreur);

569

570

for (pList = pSubWidgetList; pList != NULL && i < length; pList = pList->next, i++)

571

{

572

pOneWidget = pList->data;

573

if (bIsSpin)

574

gtk_spin_button_set_value (GTK_SPIN_BUTTON (pOneWidget), fValuesList[i]);

575

else

576

gtk_range_set_value (GTK_RANGE (pOneWidget), fValuesList[i]);

577

}

578

579

g_free (fValuesList);

580

}

581

else if (GTK_IS_COLOR_BUTTON (pOneWidget))

582

{

583

double *fValuesList = g_key_file_get_double_list (pKeyFile, cGroupName, cKeyName, &length, &erreur);

584

585

if (length > 2)

586

{

587

GdkColor gdkColor;

588

gdkColor.red = fValuesList[0] * 65535;

589

gdkColor.green = fValuesList[1] * 65535;

590

gdkColor.blue = fValuesList[2] * 65535;

591

gtk_color_button_set_color (GTK_COLOR_BUTTON (pOneWidget), &gdkColor);

592

593

if (length > 3 && gtk_color_button_get_use_alpha (GTK_COLOR_BUTTON (pOneWidget)))

594

gtk_color_button_set_alpha (GTK_COLOR_BUTTON (pOneWidget), fValuesList[3] * 65535);

595

}

596

g_free (fValuesList);

597

}

598

g_key_file_free (pKeyFile);

599

}

600

601

static void _cairo_dock_key_grab_cb (GtkWidget *wizard_window, GdkEventKey *event, GtkEntry *pEntry)

602

{

603

gchar *key;

604

cd_message ("key press event\n");

605

if (gtk_accelerator_valid (event->keyval, event->state))

606

{

607

/* This lets us ignore all ignorable modifier keys, including

608

* NumLock and many others. :)

609

610

* The logic is: keep only the important modifiers that were pressed

611

* for this event. */

612

event->state &= gtk_accelerator_get_default_mod_mask();

613

614

/* Generate the correct name for this key */

615

key = gtk_accelerator_name (event->keyval, event->state);

616

617

g_printerr ("KEY GRABBED: %s\n", key);

618

619

/* Re-enable widgets */

620

gtk_widget_set_sensitive (GTK_WIDGET(pEntry), TRUE);

621

622

/* Disconnect the key grabber */

623

g_signal_handlers_disconnect_by_func (GTK_OBJECT(wizard_window), GTK_SIGNAL_FUNC(_cairo_dock_key_grab_cb), pEntry);

624

625

/* Copy the pressed key to the text entry */

626

gtk_entry_set_text (GTK_ENTRY(pEntry), key);

627

628

/* Free the string */

629

g_free (key);

630

}

631

}

632

633

static void _cairo_dock_key_grab_clicked (GtkButton *button, gpointer *data)

634

{

635

GtkEntry *pEntry = data[0];

636

GtkWindow *pParentWindow = data[1];

637

638

cd_message ("clicked\n");

639

//set widget insensitive

640

gtk_widget_set_sensitive (GTK_WIDGET(pEntry), FALSE);

641

// gtk_widget_set_sensitive (wizard_notebook, FALSE);

642

643

g_signal_connect (GTK_WIDGET(pParentWindow), "key-press-event", GTK_SIGNAL_FUNC(_cairo_dock_key_grab_cb), pEntry);

644

}

645

646

static void _cairo_dock_key_grab_class (GtkButton *button, gpointer *data)

647

{

648

GtkEntry *pEntry = data[0];

649

GtkWindow *pParentWindow = data[1];

650

651

cd_message ("clicked\n");

652

gtk_widget_set_sensitive (GTK_WIDGET(pEntry), FALSE); // locked (plus zoli :) )

653

654

gchar *cProp = cairo_dock_launch_command_sync ("xprop"); // avec "| grep CLASS | cut -d\\\" -f2", ca ne fonctionne pas et Fab n'aime pas les g_spawn_command_line_sync :) --> c'est surtout que c'est g_spawn_command_line_sync qui n'aime pas les grep.

655

656

gchar *str = g_strstr_len (cProp, -1, "WM_CLASS(STRING)"); // str pointant sur WM_

657

gchar *cResult = NULL; // NON CE N'EST PAS MA MOYENNE DE POINT !!!!

658

if (str != NULL)

659

{

660

// WM_CLASS(STRING) = "gnome-terminal", "Gnome-terminal" \\ => utiliser le 2è

661

str = strchr (str, ',');

662

str += 3;

663

gchar *max = strchr (str, '"'); // on pointe le 2e "

664

if (max != NULL)

665

cResult = g_strndup (str, max - str); // on prend ce qui est entre ""

666

}

667

if (cResult == NULL)

668

cd_warning ("couldn't find the class of this window.");

669

670

gtk_widget_set_sensitive (GTK_WIDGET(pEntry), TRUE); // unlocked

671

gtk_entry_set_text (pEntry, cResult); // on ajoute le txt dans le box des accuses

672

g_free (cProp); // Ah, mnt C Propr' !

673

g_free (cResult); // Ou qu'elle est la poulette ???

674

}

675

676

void _cairo_dock_set_value_in_pair (GtkSpinButton *pSpinButton, gpointer *data)

677

{

678

GtkWidget *pPairSpinButton = data[0];

679

GtkWidget *pToggleButton = data[1];

680

if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pToggleButton)))

681

{

682

int iValue = gtk_spin_button_get_value (pSpinButton);

683

int iPairValue = gtk_spin_button_get_value (GTK_SPIN_BUTTON (pPairSpinButton));

684

if (iValue != iPairValue)

685

{

686

gtk_spin_button_set_value (GTK_SPIN_BUTTON (pPairSpinButton), iValue);

687

}

688

}

689

}

690

691

static void _cairo_dock_toggle_control_button (GtkCheckButton *pButton, gpointer *data)

692

{

693

GtkWidget *parent = data[1];

694

GtkWidget *pKeyBox = data[0];

695

int iNbWidgets = GPOINTER_TO_INT (data[2]);

696

697

GList *children = gtk_container_get_children (GTK_CONTAINER (parent));

698

GList *c = g_list_find (children, pKeyBox);

699

g_return_if_fail (c != NULL);

700

701

gboolean bActive = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pButton));

702

GtkWidget *w;

703

int i;

704

for (c = c->next, i = 0; c != NULL && i < iNbWidgets; c = c->next, i ++)

705

{

706

w = c->data;

707

g_print (" %d/%d -> %d\n", i, iNbWidgets, bActive);

708

gtk_widget_set_sensitive (w, bActive);

709

}

710

711

g_list_free (children);

712

}

713

714

static void _list_icon_theme_in_dir (const gchar *cDirPath, GHashTable *pHashTable)

715

{

716

GError *erreur = NULL;

717

GDir *dir = g_dir_open (cDirPath, 0, &erreur);

718

if (erreur != NULL)

719

{

720

cd_warning ("%s\n", erreur->message);

721

g_error_free (erreur);

722

return ;

723

}

724

725

const gchar *cFileName;

726

gchar *cContent;

727

gsize length;

728

GString *sIndexFile = g_string_new ("");

729

while ((cFileName = g_dir_read_name (dir)) != NULL)

730

{

731

g_string_printf (sIndexFile, "%s/%s/index.theme", cDirPath, cFileName);

732

if (! g_file_test (sIndexFile->str, G_FILE_TEST_EXISTS))

733

continue;

734

735

GKeyFile *pKeyFile = cairo_dock_open_key_file (sIndexFile->str);

736

if (pKeyFile == NULL)

737

continue;

738

739

if (! g_key_file_get_boolean (pKeyFile, "Icon Theme", "Hidden", NULL) && g_key_file_has_key (pKeyFile, "Icon Theme", "Directories", NULL))

740

{

741

gchar *cName = g_key_file_get_string (pKeyFile, "Icon Theme", "Name", NULL);

742

if (cName != NULL)

743

{

744

g_hash_table_insert (pHashTable, cName, g_strdup (cName));

745

}

746

}

747

748

g_key_file_free (pKeyFile);

749

}

750

g_string_free (sIndexFile, TRUE);

751

g_dir_close (dir);

752

}

753

754

static GHashTable *_cairo_dock_build_icon_themes_list (const gchar **cDirs)

755

{

756

GHashTable *pHashTable = g_hash_table_new_full (g_str_hash,

757

g_str_equal,

758

g_free,

759

g_free);

760

gchar *cName = g_strdup (N_("_Custom Icons_"));

761

g_hash_table_insert (pHashTable, cName, g_strdup (gettext (cName)));

762

763

int i;

764

for (i = 0; cDirs[i] != NULL; i ++)

765

{

766

_list_icon_theme_in_dir (cDirs[i], pHashTable);

767

}

768

return pHashTable;

769

}

770

771

static gboolean _add_module_to_modele (gchar *cModuleName, CairoDockModule *pModule, gpointer *data)

772

{

773

int iCategory = GPOINTER_TO_INT (data[0]);

774

if (pModule->pVisitCard->iCategory == iCategory || (iCategory == -1 && pModule->pVisitCard->iCategory != CAIRO_DOCK_CATEGORY_SYSTEM && pModule->pVisitCard->iCategory != CAIRO_DOCK_CATEGORY_THEME && ! cairo_dock_module_is_auto_loaded (pModule)))

775

{

776

//g_print (" + %s\n", pModule->pVisitCard->cIconFilePath);

777

GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file_at_size (pModule->pVisitCard->cIconFilePath, 32, 32, NULL);

778

GtkListStore *pModele = data[1];

779

GtkTreeIter iter;

780

memset (&iter, 0, sizeof (GtkTreeIter));

781

gtk_list_store_append (GTK_LIST_STORE (pModele), &iter);

782

gtk_list_store_set (GTK_LIST_STORE (pModele), &iter,

783

CAIRO_DOCK_MODEL_NAME, dgettext (pModule->pVisitCard->cGettextDomain, pModule->pVisitCard->cModuleName), /// cTitle ?...

784

CAIRO_DOCK_MODEL_RESULT, cModuleName,

785

CAIRO_DOCK_MODEL_DESCRIPTION_FILE, dgettext (pModule->pVisitCard->cGettextDomain, pModule->pVisitCard->cDescription),

786

CAIRO_DOCK_MODEL_IMAGE, pModule->pVisitCard->cPreviewFilePath,

787

CAIRO_DOCK_MODEL_ICON, pixbuf,

788

CAIRO_DOCK_MODEL_STATE, pModule->pVisitCard->iCategory,

789

CAIRO_DOCK_MODEL_ACTIVE, (pModule->pInstancesList != NULL), -1);

790

g_object_unref (pixbuf);

791

}

792

return FALSE;

793

}

794

795

static void _cairo_dock_activate_one_module (GtkCellRendererToggle * cell_renderer, gchar * path, GtkTreeModel * model)

796

{

797

GtkTreeIter iter;

798

if (! gtk_tree_model_get_iter_from_string (model, &iter, path))

799

return ;

800

gchar *cModuleName = NULL;

801

gboolean bState;

802

gtk_tree_model_get (model, &iter,

803

CAIRO_DOCK_MODEL_RESULT, &cModuleName,

804

CAIRO_DOCK_MODEL_ACTIVE, &bState, -1);

805

806

bState = !bState;

807

gtk_list_store_set (GTK_LIST_STORE (model), &iter, CAIRO_DOCK_MODEL_ACTIVE, bState, -1);

808

809

/// passer en gras ?...

810

811

CairoDockModule *pModule = cairo_dock_find_module_from_name (cModuleName);

812

if (g_pMainDock == NULL)

813

{

814

cairo_dock_add_remove_element_to_key (g_cConfFile, "System", "modules", cModuleName, bState);

815

}

816

else if (pModule->pInstancesList == NULL)

817

{

818

cairo_dock_activate_module_and_load (cModuleName);

819

}

820

else

821

{

822

cairo_dock_deactivate_module_and_unload (cModuleName);

823

}

824

g_free (cModuleName);

825

}

826

827

#define _build_list_for_gui(pListStore, cEmptyItem, pHashTable, pHFunction) do { \

828

if (pListStore != NULL)\

829

g_object_unref (pListStore);\

830

if (pHashTable == NULL) {\

831

pListStore = NULL;\

832

return ; }\

833

pListStore = _allocate_new_model ();\

834

gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (pListStore), CAIRO_DOCK_MODEL_NAME, GTK_SORT_ASCENDING);\

835

if (cEmptyItem) {\

836

pHFunction (cEmptyItem, NULL, pListStore); }\

837

g_hash_table_foreach (pHashTable, (GHFunc) pHFunction, pListStore); } while (0)

838

839

static void _cairo_dock_add_one_renderer_item (const gchar *cName, CairoDockRenderer *pRenderer, GtkListStore *pModele)

840

{

841

GtkTreeIter iter;

842

memset (&iter, 0, sizeof (GtkTreeIter));

843

gtk_list_store_append (GTK_LIST_STORE (pModele), &iter);

844

gtk_list_store_set (GTK_LIST_STORE (pModele), &iter,

845

CAIRO_DOCK_MODEL_NAME, (pRenderer && pRenderer->cDisplayedName ? pRenderer->cDisplayedName : cName),

846

CAIRO_DOCK_MODEL_RESULT, cName,

847

CAIRO_DOCK_MODEL_DESCRIPTION_FILE, (pRenderer != NULL ? pRenderer->cReadmeFilePath : "none"),

848

CAIRO_DOCK_MODEL_IMAGE, (pRenderer != NULL ? pRenderer->cPreviewFilePath : "none"), -1);

849

}

850

void cairo_dock_build_renderer_list_for_gui (GHashTable *pHashTable)

851

{

852

_build_list_for_gui (s_pRendererListStore, "", pHashTable, _cairo_dock_add_one_renderer_item);

853

}

854

static void _cairo_dock_add_one_decoration_item (const gchar *cName, CairoDeskletDecoration *pDecoration, GtkListStore *pModele)

855

{

856

GtkTreeIter iter;

857

memset (&iter, 0, sizeof (GtkTreeIter));

858

gtk_list_store_append (GTK_LIST_STORE (pModele), &iter);

859

gtk_list_store_set (GTK_LIST_STORE (pModele), &iter,

860

CAIRO_DOCK_MODEL_NAME, (pDecoration && pDecoration->cDisplayedName && *pDecoration->cDisplayedName != '\0' ? pDecoration->cDisplayedName : cName),

861

CAIRO_DOCK_MODEL_RESULT, cName,

862

CAIRO_DOCK_MODEL_DESCRIPTION_FILE, "none"/*(pRenderer != NULL ? pRenderer->cReadmeFilePath : "none")*/,

863

CAIRO_DOCK_MODEL_IMAGE, "none"/*(pRenderer != NULL ? pRenderer->cPreviewFilePath : "none")*/, -1);

864

}

865

void cairo_dock_build_desklet_decorations_list_for_gui (GHashTable *pHashTable)

866

{

867

_build_list_for_gui (s_pDecorationsListStore, NULL, pHashTable, _cairo_dock_add_one_decoration_item);

868

}

869

void cairo_dock_build_desklet_decorations_list_for_applet_gui (GHashTable *pHashTable)

870

{

871

_build_list_for_gui (s_pDecorationsListStore2, "default", pHashTable, _cairo_dock_add_one_decoration_item);

872

}

873

static void _cairo_dock_add_one_animation_item (const gchar *cName, CairoDockAnimationRecord *pRecord, GtkListStore *pModele)

874

{

875

GtkTreeIter iter;

876

memset (&iter, 0, sizeof (GtkTreeIter));

877

gtk_list_store_append (GTK_LIST_STORE (pModele), &iter);

878

gtk_list_store_set (GTK_LIST_STORE (pModele), &iter,

879

CAIRO_DOCK_MODEL_NAME, (pRecord && pRecord->cDisplayedName != NULL && *pRecord->cDisplayedName != '\0' ? pRecord->cDisplayedName : cName),

880

CAIRO_DOCK_MODEL_RESULT, cName,

881

CAIRO_DOCK_MODEL_DESCRIPTION_FILE, "none",

882

CAIRO_DOCK_MODEL_IMAGE, "none", -1);

883

}

884

void cairo_dock_build_animations_list_for_gui (GHashTable *pHashTable)

885

{

886

_build_list_for_gui (s_pAnimationsListStore, "", pHashTable, _cairo_dock_add_one_animation_item);

887

}

888

889

static void _cairo_dock_add_one_dialog_decorator_item (const gchar *cName, CairoDialogDecorator *pDecorator, GtkListStore *pModele)

890

{

891

GtkTreeIter iter;

892

memset (&iter, 0, sizeof (GtkTreeIter));

893

gtk_list_store_append (GTK_LIST_STORE (pModele), &iter);

894

gtk_list_store_set (GTK_LIST_STORE (pModele), &iter,

895

CAIRO_DOCK_MODEL_NAME, (pDecorator && pDecorator->cDisplayedName != NULL && *pDecorator->cDisplayedName != '\0' ? pDecorator->cDisplayedName : cName),

896

CAIRO_DOCK_MODEL_RESULT, cName,

897

CAIRO_DOCK_MODEL_DESCRIPTION_FILE, "none",

898

CAIRO_DOCK_MODEL_IMAGE, "none", -1);

899

}

900

void cairo_dock_build_dialog_decorator_list_for_gui (GHashTable *pHashTable)

901

{

902

_build_list_for_gui (s_pDialogDecoratorListStore, NULL, pHashTable, _cairo_dock_add_one_dialog_decorator_item);

903

}

904

905

static void _cairo_dock_add_one_gauge_item (const gchar *cName, CairoDialogDecorator *pDecorator, GtkListStore *pModele)

906

{

907

GtkTreeIter iter;

908

memset (&iter, 0, sizeof (GtkTreeIter));

909

gtk_list_store_append (GTK_LIST_STORE (pModele), &iter);

910

gtk_list_store_set (GTK_LIST_STORE (pModele), &iter,

911

CAIRO_DOCK_MODEL_NAME, cName != NULL && *cName != '\0' ? gettext (cName) : cName,

912

CAIRO_DOCK_MODEL_RESULT, cName,

913

CAIRO_DOCK_MODEL_DESCRIPTION_FILE, "none",

914

CAIRO_DOCK_MODEL_IMAGE, "none", -1);

915

}

916

static void cairo_dock_build_gauge_list_for_gui (GHashTable *pHashTable)

917

{

918

_build_list_for_gui (s_pGaugeListStore, NULL, pHashTable, _cairo_dock_add_one_gauge_item);

919

}

920

921

static void _cairo_dock_add_one_dock_item (const gchar *cName, CairoDock *pDock, GtkListStore *pModele)

922

{

923

if (pDock != NULL) // peut etre NULL (entree vide)

924

{

925

Icon *pPointingIcon = cairo_dock_search_icon_pointing_on_dock (pDock, NULL);

926

if (CAIRO_DOCK_IS_APPLET (pPointingIcon) || CAIRO_DOCK_IS_MULTI_APPLI (pPointingIcon))

927

return ;

928

}

929

GtkTreeIter iter;

930

memset (&iter, 0, sizeof (GtkTreeIter));

931

gtk_list_store_append (GTK_LIST_STORE (pModele), &iter);

932

gtk_list_store_set (GTK_LIST_STORE (pModele), &iter,

933

CAIRO_DOCK_MODEL_NAME, cName,

934

CAIRO_DOCK_MODEL_RESULT, cName,

935

CAIRO_DOCK_MODEL_DESCRIPTION_FILE, "none",

936

CAIRO_DOCK_MODEL_IMAGE, "none", -1);

937

}

938

static void cairo_dock_build_dock_list_for_gui (void)

939

{

940

if (s_pDocksListStore != NULL)

941

g_object_unref (s_pDocksListStore);

942

s_pDocksListStore = _allocate_new_model ();

943

_cairo_dock_add_one_dock_item ("", NULL, s_pDocksListStore);

944

cairo_dock_foreach_docks ((GHFunc) _cairo_dock_add_one_dock_item, s_pDocksListStore);

945

}

946

947

static void _cairo_dock_add_one_icon_theme_item (const gchar *cName, const gchar *cDisplayedName, GtkListStore *pModele)

948

{

949

GtkTreeIter iter;

950

memset (&iter, 0, sizeof (GtkTreeIter));

951

gtk_list_store_append (GTK_LIST_STORE (pModele), &iter);

952

//g_print ("+ %s (%s)\n", cName, cDisplayedName);

953

gtk_list_store_set (GTK_LIST_STORE (pModele), &iter,

954

CAIRO_DOCK_MODEL_NAME, cDisplayedName,

955

CAIRO_DOCK_MODEL_RESULT, cName,

956

CAIRO_DOCK_MODEL_DESCRIPTION_FILE, "none",

957

CAIRO_DOCK_MODEL_IMAGE, "none", -1);

958

}

959

static void cairo_dock_build_icon_theme_list_for_gui (GHashTable *pHashTable)

960

{

961

_build_list_for_gui (s_pIconThemeListStore, "", pHashTable, _cairo_dock_add_one_icon_theme_item);

962

}

963

964

static inline void _fill_modele_with_themes (const gchar *cThemeName, CairoDockTheme *pTheme, GtkListStore *pModele, gboolean bShowState, gboolean bInsertState)

965

{

966

GtkTreeIter iter;

967

memset (&iter, 0, sizeof (GtkTreeIter));

968

gtk_list_store_append (GTK_LIST_STORE (pModele), &iter);

969

gchar *cReadmePath = g_strdup_printf ("%s/readme", pTheme->cThemePath);

970

gchar *cPreviewPath = g_strdup_printf ("%s/preview", pTheme->cThemePath);

971

gchar *cResult = (bInsertState ? g_strdup_printf ("%s[%d]", cThemeName, pTheme->iType) : NULL);

972

gchar *cDisplayedName = NULL;

973

if (bShowState)

974

{

975

const gchar *cType;

976

switch (pTheme->iType)

977

{

978

case CAIRO_DOCK_LOCAL_THEME: cType = "(Local) "; break;

979

case CAIRO_DOCK_USER_THEME: cType = "(User) "; break;

980

case CAIRO_DOCK_DISTANT_THEME: cType = "(Net) "; break;

981

case CAIRO_DOCK_NEW_THEME: cType = "(New) "; break;

982

case CAIRO_DOCK_UPDATED_THEME: cType = "(Updated)"; break;

983

default: cType = ""; break;

984

}

985

cDisplayedName = g_strconcat (cType, pTheme->cDisplayedName, NULL);

986

}

987

gtk_list_store_set (GTK_LIST_STORE (pModele), &iter,

988

CAIRO_DOCK_MODEL_NAME, cDisplayedName ? cDisplayedName : pTheme->cDisplayedName,

989

CAIRO_DOCK_MODEL_RESULT, cResult ? cResult : cThemeName,

990

CAIRO_DOCK_MODEL_ACTIVE, FALSE,

991

CAIRO_DOCK_MODEL_DESCRIPTION_FILE, cReadmePath,

992

CAIRO_DOCK_MODEL_IMAGE, cPreviewPath,

993

CAIRO_DOCK_MODEL_ORDER, pTheme->iRating,

994

CAIRO_DOCK_MODEL_ORDER2, pTheme->iSobriety,

995

CAIRO_DOCK_MODEL_STATE, pTheme->iType, -1);

996

g_free (cReadmePath);

997

g_free (cPreviewPath);

998

g_free (cResult);

999

if (bShowState)

1000

g_free (cDisplayedName);

1001

}

1002

static void _cairo_dock_fill_modele_with_themes (const gchar *cThemeName, CairoDockTheme *pTheme, GtkListStore *pModele)

1003

{

1004

_fill_modele_with_themes (cThemeName, pTheme, pModele, FALSE, TRUE);

1005

}

1006

static void _cairo_dock_fill_modele_with_short_themes (const gchar *cThemeName, CairoDockTheme *pTheme, GtkListStore *pModele)

1007

{

1008

_fill_modele_with_themes (cThemeName, pTheme, pModele, TRUE, TRUE);

1009

}

1010

1011

static void _got_themes_list (GHashTable *pThemeTable, gpointer *data)

1012

{

1013

if (pThemeTable == NULL)

1014

{

1015

cairo_dock_set_status_message (data[1], "Couldn't list available themes (is connection alive ?)");

1016

return ;

1017

}

1018

else

1019

cairo_dock_set_status_message (data[1], "");

1020

GtkWidget *pTreeView = data[0];

1021

GtkListStore *modele = gtk_tree_view_get_model (GTK_TREE_VIEW (pTreeView));

1022

g_hash_table_foreach (pThemeTable, (GHFunc)_cairo_dock_fill_modele_with_themes, modele);

1023

}

1024

1025

static void _got_themes_combo_list (GHashTable *pThemeTable, gpointer *data)

1026

{

1027

if (pThemeTable == NULL)

1028

{

1029

cairo_dock_set_status_message (data[1], "Couldn't list available themes (is connection alive ?)");

1030

return ;

1031

}

1032

else

1033

cairo_dock_set_status_message (data[1], "");

1034

GtkWidget *pCombo = data[0];

1035

1036

gchar *cValue = data[2];

1037

cairo_dock_fill_combo_with_themes (pCombo, pThemeTable, cValue);

1038

g_free (cValue);

1039

data[2] = NULL;

1040

}

1041

1042

static gboolean _cairo_dock_test_one_name (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer *data)

1043

{

1044

gchar *cName = NULL, *cResult = NULL;

1045

gtk_tree_model_get (model, iter, CAIRO_DOCK_MODEL_RESULT, &cResult, -1);

1046

if (cResult == NULL)

1047

gtk_tree_model_get (model, iter, CAIRO_DOCK_MODEL_NAME, &cName, -1);

1048

else if (data[3])

1049

cairo_dock_extract_theme_type_from_name (cResult);

1050

if ((cResult && strcmp (data[0], cResult) == 0) || (cName && strcmp (data[0], cName) == 0))

1051

{

1052

GtkTreeIter *iter_to_fill = data[1];

1053

memcpy (iter_to_fill, iter, sizeof (GtkTreeIter));

1054

gboolean *bFound = data[2];

1055

*bFound = TRUE;

1056

g_free (cName);

1057

g_free (cResult);

1058

return TRUE;

1059

}

1060

g_free (cName);

1061

g_free (cResult);

1062

return FALSE;

1063

}

1064

static gboolean _cairo_dock_find_iter_from_name (GtkListStore *pModele, const gchar *cName, GtkTreeIter *iter, gboolean bIsTheme)

1065

{

1066

//g_print ("%s (%s)\n", __func__, cName);

1067

if (cName == NULL)

1068

return FALSE;

1069

gboolean bFound = FALSE;

1070

gconstpointer data[4] = {cName, iter, &bFound, GINT_TO_POINTER (bIsTheme)};

1071

gtk_tree_model_foreach (GTK_TREE_MODEL (pModele), (GtkTreeModelForeachFunc) _cairo_dock_test_one_name, data);

1072

return bFound;

1073

}

1074

1075

static void _cairo_dock_render_module_name (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell, GtkTreeModel *model,GtkTreeIter *iter, gpointer data)

1076

{

1077

gboolean bActive = FALSE;

1078

gtk_tree_model_get (model, iter, CAIRO_DOCK_MODEL_ACTIVE, &bActive, -1);

1079

1080

if (bActive)

1081

g_object_set (cell, "weight", 800, "weight-set", TRUE, NULL);

1082

else

1083

g_object_set (cell, "weight", 400, "weight-set", FALSE, NULL);

1084

}

1085

1086

static void _cairo_dock_render_category (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell, GtkTreeModel *model,GtkTreeIter *iter, gpointer data)

1087

{

1088

const gchar *cCategory=NULL;

1089

gint iCategory = 0;

1090

gtk_tree_model_get (model, iter, CAIRO_DOCK_MODEL_STATE, &iCategory, -1);

1091

switch (iCategory)

1092

{

1093

case CAIRO_DOCK_CATEGORY_APPLET_ACCESSORY:

1094

cCategory = _("Accessory");

1095

g_object_set (cell, "foreground", "#900009", NULL); // rouge

1096

g_object_set (cell, "foreground-set", TRUE, NULL);

1097

break;

1098

case CAIRO_DOCK_CATEGORY_APPLET_DESKTOP:

1099

cCategory = _("Desktop");

1100

g_object_set (cell, "foreground", "#116E08", NULL); // vert

1101

g_object_set (cell, "foreground-set", TRUE, NULL);

1102

break;

1103

case CAIRO_DOCK_CATEGORY_APPLET_CONTROLER:

1104

cCategory = _("Controler");

1105

g_object_set (cell, "foreground", "#004EA1", NULL); // bleu

1106

g_object_set (cell, "foreground-set", TRUE, NULL);

1107

break;

1108

case CAIRO_DOCK_CATEGORY_PLUG_IN:

1109

cCategory = _("Plug-in");

1110

g_object_set (cell, "foreground", "#A58B0D", NULL); // jaune

1111

g_object_set (cell, "foreground-set", TRUE, NULL);

1112

break;

1113

}

1114

if (cCategory != NULL)

1115

{

1116

g_object_set (cell, "text", cCategory, NULL);

1117

}

1118

}

1119

1120

#define CD_MAX_RATING 5

1121

static inline void _render_rating (GtkCellRenderer *cell, GtkTreeModel *model, GtkTreeIter *iter, int iColumnIndex)

1122

{

1123

gint iRating = 0;

1124

gtk_tree_model_get (model, iter, iColumnIndex, &iRating, -1);

1125

if (iRating > CD_MAX_RATING)

1126

iRating = CD_MAX_RATING;

1127

if (iRating > 0)

1128

{

1129

GString *s = g_string_sized_new (CD_MAX_RATING*4+1);

1130

int i;

1131

for (i= 0; i < iRating; i ++)

1132

g_string_append (s, "★");

1133

for (;i < CD_MAX_RATING; i ++)

1134

g_string_append (s, "☆");

1135

g_object_set (cell, "text", s->str, NULL); // markup

1136

g_string_free (s, TRUE);

1137

}

1138

else

1139

{

1140

g_object_set (cell, "text", iColumnIndex == CAIRO_DOCK_MODEL_ORDER ? _("rate me") : "-", NULL);

1141

}

1142

}

1143

static void _cairo_dock_render_sobriety (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell, GtkTreeModel *model,GtkTreeIter *iter, gpointer data)

1144

{

1145

_render_rating (cell, model, iter, CAIRO_DOCK_MODEL_ORDER2);

1146

}

1147

static void _cairo_dock_render_rating (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell, GtkTreeModel *model,GtkTreeIter *iter, gpointer data)

1148

{

1149

/// ignorer les themes "default"...

1150

_render_rating (cell, model, iter, CAIRO_DOCK_MODEL_ORDER);

1151

}

1152

static void _cairo_dock_render_state (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell, GtkTreeModel *model,GtkTreeIter *iter, gpointer data)

1153

{

1154

const gchar *cState=NULL;

1155

gint iState = 0;

1156

gtk_tree_model_get (model, iter, CAIRO_DOCK_MODEL_STATE, &iState, -1);

1157

switch (iState)

1158

{

1159

case CAIRO_DOCK_LOCAL_THEME:

1160

cState = _("Local");

1161

g_object_set (cell, "foreground-set", FALSE, NULL);

1162

break;

1163

case CAIRO_DOCK_USER_THEME:

1164

cState = _("User");

1165

g_object_set (cell, "foreground-set", FALSE, NULL);

1166

break;

1167

case CAIRO_DOCK_DISTANT_THEME:

1168

cState = _("Net");

1169

g_object_set (cell, "foreground-set", FALSE, NULL);

1170

break;

1171

case CAIRO_DOCK_NEW_THEME:

1172

cState = _("New");

1173

g_object_set (cell, "foreground", "#FF0000", NULL); // "red"

1174

g_object_set (cell, "foreground-set", TRUE, NULL);

1175

break;

1176

case CAIRO_DOCK_UPDATED_THEME:

1177

cState = _("Updated");

1178

g_object_set (cell, "foreground", "#FF0000", NULL); // "red"

1179

g_object_set (cell, "foreground-set", TRUE, NULL);

1180

break;

1181

default:

1182

break;

1183

}

1184

if (cState != NULL)

1185

{

1186

g_object_set (cell, "text", cState, NULL);

1187

}

1188

}

1189

static GtkListStore *_make_note_list_store (void)

1190

{

1191

GString *s = g_string_sized_new (CD_MAX_RATING*4+1);

1192

GtkListStore *note_list = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING);

1193

GtkTreeIter iter;

1194

int i, j;

1195

for (i = 1; i <= 5; i ++)

1196

{

1197

g_string_assign (s, "");

1198

for (j= 0; j < i; j ++)

1199

g_string_append (s, "★");

1200

for (;j < CD_MAX_RATING; j ++)

1201

g_string_append (s, "☆");

1202

1203

memset (&iter, 0, sizeof (GtkTreeIter));

1204

gtk_list_store_append (GTK_LIST_STORE (note_list), &iter);

1205

gtk_list_store_set (GTK_LIST_STORE (note_list), &iter,

1206

0, i,

1207

1, s->str, -1);

1208

}

1209

g_string_free (s, TRUE);

1210

return note_list;

1211

}

1212

static void _change_rating (GtkCellRendererText * cell, gchar * path_string, gchar * new_text, GtkTreeModel * model)

1213

{

1214

//g_print ("%s (%s : %s)\n", __func__, path_string, new_text);

1215

g_return_if_fail (new_text != NULL && *new_text != '\0');

1216

1217

GtkTreeIter it;

1218

if (! gtk_tree_model_get_iter_from_string (model, &it, path_string))

1219

return ;

1220

1221

int iRating = 0;

1222

gchar *str = new_text;

1223

1224

{

1225

if (strncmp (str, "★", strlen ("★")) == 0)

1226

{

1227

str += strlen ("★");

1228

iRating ++;

1229

}

1230

else

1231

break ;

1232

} while (1);

1233

//g_print ("iRating : %d\n", iRating);

1234

1235

gchar /** *cDisplayedName = NULL, */*cThemeName = NULL;

1236

gint iState;

1237

gtk_tree_model_get (model, &it,

1238

///CAIRO_DOCK_MODEL_NAME, &cDisplayedName,

1239

CAIRO_DOCK_MODEL_RESULT, &cThemeName,

1240

CAIRO_DOCK_MODEL_STATE, &iState, -1);

1241

g_return_if_fail (/**cDisplayedName != NULL && */cThemeName != NULL);

1242

//g_print ("theme : %s / %s\n", cThemeName, cDisplayedName);

1243

1244

gchar *cRatingDir = g_strdup_printf ("%s/%s/.rating", g_cCairoDockDataDir, "themes"); // il y'a un probleme ici, on ne connait pas le repertoire utilisateur des themes. donc ce code ne marche que pour les themes du dock (et n'est utilise que pour ca)

1245

gchar *cRatingFile = g_strdup_printf ("%s/%s", cRatingDir, cThemeName);

1246

//g_print ("on ecrit dans %s\n", cRatingFile);

1247

if (iState == CAIRO_DOCK_USER_THEME || iState == CAIRO_DOCK_LOCAL_THEME/**strncmp (cDisplayedName, CAIRO_DOCK_PREFIX_NET_THEME, strlen (CAIRO_DOCK_PREFIX_NET_THEME)) != 0*/ || g_file_test (cRatingFile, G_FILE_TEST_EXISTS)) // ca n'est pas un theme distant, ou l'utilisateur a deja vote auparavant pour ce theme.

1248

{

1249

if (!g_file_test (cRatingDir, G_FILE_TEST_IS_DIR))

1250

{

1251

if (g_mkdir (cRatingDir, 7*8*8+7*8+5) != 0)

1252

{

1253

cd_warning ("couldn't create directory %s", cRatingDir);

1254

return ;

1255

}

1256

}

1257

gchar *cContent = g_strdup_printf ("%d", iRating);

1258

g_file_set_contents (cRatingFile,

1259

cContent,

1260

-1,

1261

NULL);

1262

g_free (cContent);

1263

1264

gtk_list_store_set (GTK_LIST_STORE (model), &it, CAIRO_DOCK_MODEL_ORDER, iRating, -1);

1265

}

1266

else

1267

{

1268

Icon *pIcon = cairo_dock_get_current_active_icon ();

1269

CairoDock *pDock = NULL;

1270

if (pIcon != NULL)

1271

pDock = cairo_dock_search_dock_from_name (pIcon->cParentDockName);

1272

if (pDock != NULL)

1273

cairo_dock_show_temporary_dialog_with_icon (_("You have to try the theme before you can rate it."), pIcon, CAIRO_CONTAINER (pDock), 3000, "same icon");

1274

else

1275

cairo_dock_show_general_message (_("You have to try the theme before you can rate it."), 3000);

1276

}

1277

///g_free (cDisplayedName);

1278

g_free (cThemeName);

1279

g_free (cRatingFile);

1280

g_free (cRatingDir);

1281

}

1282

1283

static void _cairo_dock_configure_module (GtkButton *button, gpointer *data)

1284

{

1285

GtkTreeView *pCombo = data[0];

1286

GtkWindow *pDialog = data[1];

1287

gchar *cModuleName = data[2];

1288

1289

CairoDockModule *pModule = cairo_dock_find_module_from_name (cModuleName);

1290

CairoDockInternalModule *pInternalModule = cairo_dock_find_internal_module_from_name (cModuleName);

1291

Icon *pIcon = cairo_dock_get_current_active_icon ();

1292

CairoDock *pDock = cairo_dock_search_dock_from_name (pIcon != NULL ? pIcon->cParentDockName : NULL);

1293

gchar *cMessage = NULL;

1294

1295

if (pModule == NULL && pInternalModule == NULL)

1296

{

1297

cMessage = g_strdup_printf (_("The '%s' module was not found.\nBe sure to install it in the same version as the dock to enjoy these features."), cModuleName);

1298

int iDuration = 10e3;

1299

if (pIcon != NULL && pDock != NULL)

1300

cairo_dock_show_temporary_dialog_with_icon (cMessage, pIcon, CAIRO_CONTAINER (pDock), iDuration, "same icon");

1301

else

1302

cairo_dock_show_general_message (cMessage, iDuration);

1303

}

1304

else if (pModule != NULL && pModule->pInstancesList == NULL)

1305

{

1306

cMessage = g_strdup_printf (_("The '%s' plug-in is not active.\nBe sure to activate it to enjoy these features."), cModuleName);

1307

int iDuration = 8e3;

1308

if (pIcon != NULL && pDock != NULL)

1309

cairo_dock_show_temporary_dialog_with_icon (cMessage, pIcon, CAIRO_CONTAINER (pDock), iDuration, "same icon");

1310

}

1311

else

1312

{

1313

cairo_dock_show_module_gui (cModuleName);

1314

}

1315

g_free (cMessage);

1316

}

1317

1318

#define _allocate_new_buffer\

1319

data = g_new (gconstpointer, 3); \

1320

g_ptr_array_add (pDataGarbage, data);

1321

1322

#define _pack_in_widget_box(pSubWidget) gtk_box_pack_start (GTK_BOX (pWidgetBox), pSubWidget, FALSE, FALSE, 0)

1323

#define _pack_subwidget(pSubWidget) do {\

1324

pSubWidgetList = g_slist_append (pSubWidgetList, pSubWidget);\

1325

_pack_in_widget_box (pSubWidget); } while (0)

1326

#define _pack_hscale(pSubWidget) do {\

1327

GtkWidget *pExtendedWidget;\

1328

if (pAuthorizedValuesList != NULL && pAuthorizedValuesList[0] != NULL && pAuthorizedValuesList[1] != NULL && pAuthorizedValuesList[2] != NULL && pAuthorizedValuesList[3] != NULL) {\

1329

pExtendedWidget = gtk_hbox_new (FALSE, 0);\

1330

GtkWidget *label = gtk_label_new (dgettext (cGettextDomain, pAuthorizedValuesList[2]));\

1331

GtkWidget *pAlign = gtk_alignment_new (1., 1., 0., 0.);\

1332

gtk_container_add (GTK_CONTAINER (pAlign), label);\

1333

gtk_box_pack_start (GTK_BOX (pExtendedWidget), pAlign, FALSE, FALSE, 0);\

1334

gtk_box_pack_start (GTK_BOX (pExtendedWidget), pSubWidget, FALSE, FALSE, 0);\

1335

label = gtk_label_new (dgettext (cGettextDomain, pAuthorizedValuesList[3]));\

1336

pAlign = gtk_alignment_new (1., 1., 0., 0.);\

1337

gtk_container_add (GTK_CONTAINER (pAlign), label);\

1338

gtk_box_pack_start (GTK_BOX (pExtendedWidget), pAlign, FALSE, FALSE, 0); }\

1339

else {\

1340

pExtendedWidget = pOneWidget; }\

1341

pSubWidgetList = g_slist_append (pSubWidgetList, pSubWidget);\

1342

_pack_in_widget_box (pExtendedWidget); } while (0)

1343

#define _add_combo_from_modele(modele, bAddPreviewWidgets, bWithEntry) do {\

1344

if (modele == NULL) { \

1345

pOneWidget = gtk_combo_box_entry_new ();\

1346

_pack_subwidget (pOneWidget); }\

1347

else {\

1348

cValue = g_key_file_get_string (pKeyFile, cGroupName, cKeyName, NULL);\

1349

if (bWithEntry) {\

1350

pOneWidget = gtk_combo_box_entry_new_with_model (GTK_TREE_MODEL (modele), CAIRO_DOCK_MODEL_NAME); }\

1351

else {\

1352

pOneWidget = gtk_combo_box_new_with_model (GTK_TREE_MODEL (modele));\

1353

rend = gtk_cell_renderer_text_new ();\

1354

gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (pOneWidget), rend, FALSE);\

1355

gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (pOneWidget), rend, "text", CAIRO_DOCK_MODEL_NAME, NULL);}\

1356

if (bAddPreviewWidgets) {\

1357

pDescriptionLabel = gtk_label_new (NULL);\

1358

g_signal_connect (pMainWindow, "destroy-event", G_CALLBACK (on_delete_async_widget), pDescriptionLabel);\

1359

g_object_ref (pDescriptionLabel);\

1360

gtk_label_set_use_markup (GTK_LABEL (pDescriptionLabel), TRUE);\

1361

gtk_widget_set_size_request (pDescriptionLabel, 500, CAIRO_DOCK_PREVIEW_HEIGHT);\

1362

gtk_label_set_justify (GTK_LABEL (pDescriptionLabel), GTK_JUSTIFY_LEFT);\

1363

gtk_label_set_line_wrap (GTK_LABEL (pDescriptionLabel), TRUE);\

1364

pPreviewImage = gtk_image_new_from_pixbuf (NULL);\

1365

g_signal_connect (pMainWindow, "delete-event", G_CALLBACK (on_delete_async_widget), pPreviewImage);\

1366

g_object_ref (pPreviewImage);\

1367

gtk_widget_set (pPreviewImage, "height-request", CAIRO_DOCK_PREVIEW_HEIGHT, "width-request", CAIRO_DOCK_PREVIEW_WIDTH, NULL);\

1368

_allocate_new_buffer;\

1369

data[0] = pDescriptionLabel;\

1370

data[1] = pPreviewImage;\

1371

g_signal_connect (G_OBJECT (pOneWidget), "changed", G_CALLBACK (_cairo_dock_select_one_item_in_combo), data);\

1372

pPreviewBox = gtk_hbox_new (FALSE, CAIRO_DOCK_GUI_MARGIN);\

1373

gtk_box_pack_start (GTK_BOX (pAdditionalItemsVBox ? pAdditionalItemsVBox : pKeyBox), pPreviewBox, FALSE, FALSE, 0);\

1374

gtk_box_pack_start (GTK_BOX (pPreviewBox), pPreviewImage, FALSE, FALSE, 0);\

1375

gtk_box_pack_start (GTK_BOX (pPreviewBox), pDescriptionLabel, FALSE, FALSE, 0); }\

1376

if (_cairo_dock_find_iter_from_name (modele, cValue, &iter, FALSE))\

1377

gtk_combo_box_set_active_iter (GTK_COMBO_BOX (pOneWidget), &iter);\

1378

_pack_subwidget (pOneWidget);\

1379

g_free (cValue); } } while (0)

1380

1381

gchar *cairo_dock_parse_key_comment (gchar *cKeyComment, char *iElementType, guint *iNbElements, gchar ***pAuthorizedValuesList, gboolean *bAligned, gchar **cTipString)

1382

{

1383

if (cKeyComment == NULL || *cKeyComment == '\0')

1384

return NULL;

1385

1386

gchar *cUsefulComment = cKeyComment;

1387

while (*cUsefulComment == '#' || *cUsefulComment == ' ' || *cUsefulComment == '\n') // on saute les # et les espaces.

1388

cUsefulComment ++;

1389

1390

int length = strlen (cUsefulComment);

1391

while (cUsefulComment[length-1] == '\n')

1392

{

1393

cUsefulComment[length-1] = '\0';

1394

length --;

1395

}

1396

1397

1398

//\______________ On recupere le type du widget.

1399

*iElementType = *cUsefulComment;

1400

cUsefulComment ++;

1401

if (*cUsefulComment == '-' || *cUsefulComment == '+')

1402

cUsefulComment ++;

1403

1404

//\______________ On recupere le nombre d'elements du widget.

1405

*iNbElements = atoi (cUsefulComment);

1406

if (*iNbElements == 0)

1407

*iNbElements = 1;

1408

while (g_ascii_isdigit (*cUsefulComment)) // on saute les chiffres.

1409

cUsefulComment ++;

1410

while (*cUsefulComment == ' ') // on saute les espaces.

1411

cUsefulComment ++;

1412

1413

//\______________ On recupere les valeurs autorisees.

1414

if (*cUsefulComment == '[')

1415

{

1416

cUsefulComment ++;

1417

gchar *cAuthorizedValuesChain = cUsefulComment;

1418

1419

while (*cUsefulComment != '\0' && *cUsefulComment != ']')

1420

cUsefulComment ++;

1421

g_return_val_if_fail (*cUsefulComment != '\0', NULL);

1422

*cUsefulComment = '\0';

1423

cUsefulComment ++;

1424

while (*cUsefulComment == ' ') // on saute les espaces.

1425

cUsefulComment ++;

1426

1427

if (*cAuthorizedValuesChain == '\0') // rien, on prefere le savoir plutot que d'avoir une entree vide.

1428

*pAuthorizedValuesList = g_new0 (gchar *, 1);

1429

else

1430

*pAuthorizedValuesList = g_strsplit (cAuthorizedValuesChain, ";", 0);

1431

}

1432

else

1433

{

1434

*pAuthorizedValuesList = NULL;

1435

}

1436

1437

//\______________ On recupere l'alignement.

1438

int len = strlen (cUsefulComment);

1439

if (cUsefulComment[len - 1] == '\n')

1440

{

1441

len --;

1442

cUsefulComment[len] = '\0';

1443

}

1444

if (cUsefulComment[len - 1] == '/')

1445

{

1446

cUsefulComment[len - 1] = '\0';

1447

*bAligned = FALSE;

1448

}

1449

else

1450

{

1451

*bAligned = TRUE;

1452

}

1453

1454

//\______________ On recupere la bulle d'aide.

1455

gchar *str = strchr (cUsefulComment, '{');

1456

if (str != NULL && str != cUsefulComment)

1457

{

1458

if (*(str-1) == '\n')

1459

*(str-1) ='\0';

1460

else

1461

*str = '\0';

1462

1463

str ++;

1464

*cTipString = str;

1465

1466

str = strrchr (*cTipString, '}');

1467

if (str != NULL)

1468

*str = '\0';

1469

}

1470

else

1471

{

1472

*cTipString = NULL;

1473

}

1474

1475

return cUsefulComment;

1476

}

1477

1478

GtkWidget *cairo_dock_build_group_widget (GKeyFile *pKeyFile, const gchar *cGroupName, const gchar *cGettextDomain, GtkWidget *pMainWindow, GSList **pWidgetList, GPtrArray *pDataGarbage, const gchar *cOriginalConfFilePath)

1479

{

1480

g_return_val_if_fail (pKeyFile != NULL && cGroupName != NULL, NULL);

1481

gchar iIdentifier = 0;

1482

gchar *cHighLightedSentence;

1483

//GPtrArray *pDataGarbage = g_ptr_array_new ();

1484

//GPtrArray *pModelGarbage = g_ptr_array_new ();

1485

1486

gconstpointer *data;

1487

int iNbBuffers = 0;

1488

gsize length = 0;

1489

gchar **pKeyList;

1490

1491

GtkWidget *pOneWidget;

1492

GSList * pSubWidgetList;

1493

GtkWidget *pLabel=NULL, *pLabelContainer;

1494

GtkWidget *pGroupBox, *pKeyBox=NULL, *pSmallVBox, *pWidgetBox=NULL;

1495

GtkWidget *pEntry;

1496

GtkWidget *pTable;

1497

GtkWidget *pButtonAdd, *pButtonRemove;

1498

GtkWidget *pButtonDown, *pButtonUp, *pButtonConfig;

1499

GtkWidget *pButtonFileChooser, *pButtonPlay;

1500

GtkWidget *pFrame, *pFrameVBox;

1501

GtkWidget *pScrolledWindow;

1502

GtkWidget *pColorButton;

1503

GtkWidget *pFontButton;

1504

GtkWidget *pDescriptionLabel;

1505

GtkWidget *pPreviewImage;

1506

GtkWidget *pButtonConfigRenderer;

1507

GtkWidget *pToggleButton=NULL;

1508

GtkCellRenderer *rend;

1509

GtkTreeIter iter;

1510

GtkTreeSelection *selection;

1511

GtkWidget *pBackButton;

1512

GtkWidget *pControlContainer = NULL;

1513

int iFirstSensitiveWidget = 0, iNbControlledWidgets = 0, iNbSensitiveWidgets = 0;

1514

gchar *cGroupComment, *cKeyName, *cKeyComment, *cUsefulComment, *cAuthorizedValuesChain, *cTipString, **pAuthorizedValuesList, *cSmallGroupIcon=NULL, *cDisplayedGroupName=NULL; // ne pas effacer 'cTipString' et 'cUsefulComment', ils pointent dans cKeyComment.

1515

gpointer *pGroupKeyWidget;

1516

int i, j;

1517

guint k, iNbElements;

1518

int iNumPage=0, iPresentedNumPage=0;

1519

char iElementType;

1520

gboolean bValue, *bValueList;

1521

int iValue, iMinValue, iMaxValue, *iValueList;

1522

double fValue, fMinValue, fMaxValue, *fValueList;

1523

gchar *cValue, **cValueList, *cSmallIcon=NULL;

1524

GdkColor gdkColor;

1525

GtkListStore *modele;

1526

gboolean bAddBackButton;

1527

GtkWidget *pPreviewBox;

1528

GtkWidget *pAdditionalItemsVBox;

1529

gboolean bIsAligned;

1530

1531

pGroupBox = NULL;

1532

pFrame = NULL;

1533

pFrameVBox = NULL;

1534

pControlContainer = NULL;

1535

cGroupComment = g_key_file_get_comment (pKeyFile, cGroupName, NULL, NULL);

1536

if (cGroupComment != NULL)

1537

{

1538

cGroupComment[strlen(cGroupComment)-1] = '\0';

1539

gchar *str = strrchr (cGroupComment, '[');

1540

if (str != NULL)

1541

{

1542

cSmallGroupIcon = str+1;

1543

str = strrchr (cSmallGroupIcon, ']');

1544

if (str != NULL)

1545

*str = '\0';

1546

str = strrchr (cSmallGroupIcon, ';');

1547

if (str != NULL)

1548

{

1549

*str = '\0';

1550

cDisplayedGroupName = str + 1;

1551

}

1552

}

1553

}

1554

1555

pKeyList = g_key_file_get_keys (pKeyFile, cGroupName, NULL, NULL);

1556

1557

for (j = 0; pKeyList[j] != NULL; j ++)

1558

{

1559

cKeyName = pKeyList[j];

1560

1561

//\______________ On parse le commentaire.

1562

pAuthorizedValuesList = NULL;

1563

cTipString = NULL;

1564

iNbElements = 0;

1565

cKeyComment = g_key_file_get_comment (pKeyFile, cGroupName, cKeyName, NULL);

1566

cUsefulComment = cairo_dock_parse_key_comment (cKeyComment, &iElementType, &iNbElements, &pAuthorizedValuesList, &bIsAligned, &cTipString);

1567

if (cUsefulComment == NULL)

1568

{

1569

g_free (cKeyComment);

1570

continue;

1571

}

1572

if (iElementType == '[') // on gere le bug de la Glib, qui rajoute les nouvelles cles apres le commentaire du groupe suivant !

1573

{

1574

g_free (cKeyComment);

1575

continue;

1576

}

1577

1578

//\______________ On cree la boite du groupe si c'est la 1ere cle valide.

1579

if (pGroupBox == NULL) // maintenant qu'on a au moins un element dans ce groupe, on cree sa page dans le notebook.

1580

{

1581

pLabel = gtk_label_new (dgettext (cGettextDomain, cDisplayedGroupName ? cDisplayedGroupName : cGroupName));

1582

1583

pLabelContainer = NULL;

1584

GtkWidget *pAlign = NULL;

1585

if (cSmallGroupIcon != NULL && *cSmallGroupIcon != '\0')

1586

{

1587

pLabelContainer = gtk_hbox_new (FALSE, CAIRO_DOCK_ICON_MARGIN);

1588

pAlign = gtk_alignment_new (0., 0.5, 0., 0.);

1589

gtk_container_add (GTK_CONTAINER (pAlign), pLabelContainer);

1590

1591

GtkWidget *pImage = gtk_image_new ();

1592

GdkPixbuf *pixbuf;

1593

if (*cSmallGroupIcon != '/')

1594

pixbuf = gtk_widget_render_icon (pImage,

1595

cSmallGroupIcon ,

1596

GTK_ICON_SIZE_BUTTON,

1597

NULL);

1598

else

1599

pixbuf = gdk_pixbuf_new_from_file_at_size (cSmallGroupIcon, CAIRO_DOCK_TAB_ICON_SIZE, CAIRO_DOCK_TAB_ICON_SIZE, NULL);

1600

if (pixbuf != NULL)

1601

{

1602

gtk_image_set_from_pixbuf (GTK_IMAGE (pImage), pixbuf);

1603

gdk_pixbuf_unref (pixbuf);

1604

gtk_container_add (GTK_CONTAINER (pLabelContainer),

1605

pImage);

1606

}

1607

gtk_container_add (GTK_CONTAINER (pLabelContainer),

1608

pLabel);

1609

gtk_widget_show_all (pLabelContainer);

1610

}

1611

1612

pGroupBox = gtk_vbox_new (FALSE, CAIRO_DOCK_GUI_MARGIN);

1613

gtk_container_set_border_width (GTK_CONTAINER (pGroupBox), CAIRO_DOCK_GUI_MARGIN);

1614

}

1615

1616

pAdditionalItemsVBox = NULL;

1617

if (iElementType != CAIRO_DOCK_WIDGET_FRAME && iElementType != CAIRO_DOCK_WIDGET_EXPANDER && iElementType != CAIRO_DOCK_WIDGET_SEPARATOR)

1618

{

1619

//\______________ On cree la boite de la cle.

1620

if (iElementType == CAIRO_DOCK_WIDGET_THEME_LIST || iElementType == CAIRO_DOCK_WIDGET_THEME_LIST_ENTRY || iElementType == CAIRO_DOCK_WIDGET_VIEW_LIST)

1621

{

1622

pAdditionalItemsVBox = gtk_vbox_new (FALSE, 0);

1623

gtk_box_pack_start (pFrameVBox != NULL ? GTK_BOX (pFrameVBox) : GTK_BOX (pGroupBox),

1624

pAdditionalItemsVBox,

1625

FALSE,

1626

FALSE,

1627

0);

1628

pKeyBox = gtk_hbox_new (FALSE, CAIRO_DOCK_GUI_MARGIN);

1629

gtk_box_pack_start (GTK_BOX (pAdditionalItemsVBox),

1630

pKeyBox,

1631

FALSE,

1632

FALSE,

1633

0);

1634

}

1635

else

1636

{

1637

pKeyBox = (bIsAligned ? gtk_hbox_new : gtk_vbox_new) (FALSE, CAIRO_DOCK_GUI_MARGIN);

1638

gtk_box_pack_start (pFrameVBox != NULL ? GTK_BOX (pFrameVBox) : GTK_BOX (pGroupBox),

1639

pKeyBox,

1640

FALSE,

1641

FALSE,

1642

0);

1643

1644

}

1645

if (cTipString != NULL)

1646

{

1647

gtk_widget_set_tooltip_text (pKeyBox, dgettext (cGettextDomain, cTipString));

1648

}

1649

if (iNbControlledWidgets > 0 && pControlContainer != NULL)

1650

{

1651

//g_print ("ctrl (%d widgets)\n", iNbControlledWidgets);

1652

if (pControlContainer == (pFrameVBox ? pFrameVBox : pGroupBox))

1653

{

1654

//g_print ("ctrl (iNbControlledWidgets:%d, iFirstSensitiveWidget:%d, iNbSensitiveWidgets:%d)\n", iNbControlledWidgets, iFirstSensitiveWidget, iNbSensitiveWidgets);

1655

iNbControlledWidgets --;

1656

if (iFirstSensitiveWidget > 0)

1657

iFirstSensitiveWidget --;

1658

1659

GtkWidget *w = (pAdditionalItemsVBox ? pAdditionalItemsVBox : pKeyBox);

1660

if (iFirstSensitiveWidget == 0 && iNbSensitiveWidgets > 0)

1661

{

1662

//g_print (" => sensitive\n");

1663

iNbSensitiveWidgets --;

1664

if (GTK_IS_EXPANDER (w))

1665

gtk_expander_set_expanded (GTK_EXPANDER (w), TRUE);

1666

}

1667

else

1668

{

1669

//g_print (" => unsensitive\n");

1670

if (!GTK_IS_EXPANDER (w))

1671

gtk_widget_set_sensitive (w, FALSE);

1672

}

1673

}

1674

}

1675

1676

//\______________ On cree le label descriptif et la boite du widget.

1677

if (iElementType != CAIRO_DOCK_WIDGET_EMPTY_WIDGET)

1678

{

1679

pLabel = NULL;

1680

if (iElementType == CAIRO_DOCK_WIDGET_HANDBOOK)

1681

{

1682

cValue = g_key_file_get_string (pKeyFile, cGroupName, cKeyName, NULL);

1683

CairoDockModule *pModule = cairo_dock_find_module_from_name (cValue);

1684

if (pModule != NULL)

1685

{

1686

gchar *cDescription = g_strdup_printf ("%s (v%s) by %s\n%s",

1687

pModule->pVisitCard->cModuleName,

1688

pModule->pVisitCard->cModuleVersion,

1689

pModule->pVisitCard->cAuthor,

1690

dgettext (pModule->pVisitCard->cGettextDomain,

1691

pModule->pVisitCard->cDescription));

1692

pLabel = gtk_label_new (cDescription);

1693

gtk_widget_set (pLabel, "width-request", 500, NULL); // CAIRO_DOCK_PREVIEW_WIDTH

1694

gtk_label_set_justify (GTK_LABEL (pLabel), GTK_JUSTIFY_LEFT);

1695

gtk_label_set_line_wrap (GTK_LABEL (pLabel), TRUE);

1696

g_free (cDescription);

1697

}

1698

g_free (cValue);

1699

}

1700

else if (*cUsefulComment != '\0' && strcmp (cUsefulComment, "...") != 0)

1701

{

1702

pLabel = gtk_label_new (NULL);

1703

gtk_label_set_use_markup (GTK_LABEL (pLabel), TRUE);

1704

gtk_label_set_markup (GTK_LABEL (pLabel), dgettext (cGettextDomain, cUsefulComment));

1705

}

1706

if (pLabel != NULL)

1707

{

1708

GtkWidget *pAlign = gtk_alignment_new (0., 0.5, 0., 0.);

1709

gtk_container_add (GTK_CONTAINER (pAlign), pLabel);

1710

gtk_box_pack_start (GTK_BOX (pKeyBox),

1711

pAlign,

1712

FALSE,

1713

FALSE,

1714

0);

1715

}

1716

1717

pWidgetBox = gtk_hbox_new (FALSE, CAIRO_DOCK_GUI_MARGIN);

1718

gtk_box_pack_end (GTK_BOX (pKeyBox),

1719

pWidgetBox,

1720

FALSE,

1721

FALSE,

1722

0);

1723

}

1724

}

1725

1726

pSubWidgetList = NULL;

1727

bAddBackButton = FALSE;

1728

1729

//\______________ On cree les widgets selon leur type.

1730

switch (iElementType)

1731

{

1732

case CAIRO_DOCK_WIDGET_CHECK_BUTTON : // boolean

1733

case CAIRO_DOCK_WIDGET_CHECK_CONTROL_BUTTON : // boolean qui controle le widget suivant

1734

length = 0;

1735

bValueList = g_key_file_get_boolean_list (pKeyFile, cGroupName, cKeyName, &length, NULL);

1736

1737

for (k = 0; k < iNbElements; k ++)

1738

{

1739

bValue = (k < length ? bValueList[k] : FALSE);

1740

pOneWidget = gtk_check_button_new ();

1741

gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pOneWidget), bValue);

1742

1743

if (iElementType == CAIRO_DOCK_WIDGET_CHECK_CONTROL_BUTTON)

1744

{

1745

_allocate_new_buffer;

1746

data[0] = pKeyBox;

1747

data[1] = pFrameVBox != NULL ? pFrameVBox : pGroupBox;

1748

if (pAuthorizedValuesList != NULL && pAuthorizedValuesList[0] != NULL)

1749

iNbControlledWidgets = g_ascii_strtod (pAuthorizedValuesList[0], NULL);

1750

else

1751

iNbControlledWidgets = 1;

1752

data[2] = GINT_TO_POINTER (iNbControlledWidgets);

1753

g_signal_connect (G_OBJECT (pOneWidget), "toggled", G_CALLBACK(_cairo_dock_toggle_control_button), data);

1754

if (! bValue) // les widgets suivants seront inactifs.

1755

{

1756

iNbSensitiveWidgets = 0;

1757

iFirstSensitiveWidget = 1;

1758

pControlContainer = pFrameVBox != NULL ? pFrameVBox : pGroupBox;

1759

}

1760

else

1761

iNbControlledWidgets = 0;

1762

}

1763

1764

_pack_subwidget (pOneWidget);

1765

}

1766

g_free (bValueList);

1767

break;

1768

1769

case CAIRO_DOCK_WIDGET_SPIN_INTEGER : // integer

1770

case CAIRO_DOCK_WIDGET_HSCALE_INTEGER : // integer dans un HScale

1771

case CAIRO_DOCK_WIDGET_SIZE_INTEGER : // double integer WxH

1772

if (pAuthorizedValuesList != NULL && pAuthorizedValuesList[0] != NULL)

1773

{

1774

iMinValue = g_ascii_strtod (pAuthorizedValuesList[0], NULL);

1775

if (pAuthorizedValuesList[1] != NULL)

1776

iMaxValue = g_ascii_strtod (pAuthorizedValuesList[1], NULL);

1777

else

1778

iMaxValue = 9999;

1779

}

1780

else

1781

{

1782

iMinValue = 0;

1783

iMaxValue = 9999;

1784

}

1785

if (iElementType == CAIRO_DOCK_WIDGET_SIZE_INTEGER)

1786

iNbElements *= 2;

1787

length = 0;

1788

iValueList = g_key_file_get_integer_list (pKeyFile, cGroupName, cKeyName, &length, NULL);

1789

GtkWidget *pPrevOneWidget=NULL;

1790

int iPrevValue=0;

1791

if (iElementType == CAIRO_DOCK_WIDGET_SIZE_INTEGER)

1792

{

1793

pToggleButton = gtk_toggle_button_new ();

1794

GtkWidget *pImage = gtk_image_new_from_stock (GTK_STOCK_MEDIA_PAUSE, GTK_ICON_SIZE_MENU); // trouver une image...

1795

gtk_button_set_image (GTK_BUTTON (pToggleButton), pImage);

1796

}

1797

for (k = 0; k < iNbElements; k ++)

1798

{

1799

iValue = (k < length ? iValueList[k] : 0);

1800

GtkObject *pAdjustment = gtk_adjustment_new (iValue,

1801

1802

1803

1804

MAX (1, (iMaxValue - iMinValue) / 20),

1805

0);

1806

1807

if (iElementType == CAIRO_DOCK_WIDGET_HSCALE_INTEGER)

1808

{

1809

pOneWidget = gtk_hscale_new (GTK_ADJUSTMENT (pAdjustment));

1810

gtk_scale_set_digits (GTK_SCALE (pOneWidget), 0);

1811

gtk_widget_set (pOneWidget, "width-request", 150, NULL);

1812

1813

_pack_hscale (pOneWidget);

1814

}

1815

else

1816

{

1817

pOneWidget = gtk_spin_button_new (GTK_ADJUSTMENT (pAdjustment), 1., 0);

1818

1819

_pack_subwidget (pOneWidget);

1820

}

1821

g_object_set (pAdjustment, "lower", (double) iMinValue, "upper", (double) iMaxValue, NULL); // le 'width-request' sur un GtkHScale avec 'fMinValue' non nul plante ! Donc on les met apres...

1822

gtk_adjustment_set_value (GTK_ADJUSTMENT (pAdjustment), iValue);

1823

1824

if (iElementType == CAIRO_DOCK_WIDGET_SIZE_INTEGER && k+1 < iNbElements) // on rajoute le separateur.

1825

{

1826

GtkWidget *pLabelX = gtk_label_new ("x");

1827

_pack_in_widget_box (pLabelX);

1828

}

1829

if (iElementType == CAIRO_DOCK_WIDGET_SIZE_INTEGER && (k&1)) // on lie les 2 spins entre eux.

1830

{

1831

if (iPrevValue == iValue)

1832

gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pToggleButton), TRUE);

1833

_allocate_new_buffer;

1834

data[0] = pPrevOneWidget;

1835

data[1] = pToggleButton;

1836

g_signal_connect (G_OBJECT (pOneWidget), "value-changed", G_CALLBACK(_cairo_dock_set_value_in_pair), data);

1837

_allocate_new_buffer;

1838

data[0] = pOneWidget;

1839

data[1] = pToggleButton;

1840

g_signal_connect (G_OBJECT (pPrevOneWidget), "value-changed", G_CALLBACK(_cairo_dock_set_value_in_pair), data);

1841

}

1842

pPrevOneWidget = pOneWidget;

1843

iPrevValue = iValue;

1844

}

1845

if (iElementType == CAIRO_DOCK_WIDGET_SIZE_INTEGER)

1846

{

1847

_pack_in_widget_box (pToggleButton);

1848

}

1849

bAddBackButton = TRUE;

1850

g_free (iValueList);

1851

break;

1852

1853

case CAIRO_DOCK_WIDGET_SPIN_DOUBLE : // float.

1854

case CAIRO_DOCK_WIDGET_HSCALE_DOUBLE : // float dans un HScale.

1855

if (pAuthorizedValuesList != NULL && pAuthorizedValuesList[0] != NULL)

1856

fMinValue = g_ascii_strtod (pAuthorizedValuesList[0], NULL);

1857

else

1858

fMinValue = 0;

1859

if (pAuthorizedValuesList != NULL && pAuthorizedValuesList[1] != NULL)

1860

fMaxValue = g_ascii_strtod (pAuthorizedValuesList[1], NULL);

1861

else

1862

fMaxValue = 9999;

1863

length = 0;

1864

fValueList = g_key_file_get_double_list (pKeyFile, cGroupName, cKeyName, &length, NULL);

1865

for (k = 0; k < iNbElements; k ++)

1866

{

1867

fValue = (k < length ? fValueList[k] : 0);

1868

1869

GtkObject *pAdjustment = gtk_adjustment_new (fValue,

1870

1871

1872

(fMaxValue - fMinValue) / 20.,

1873

(fMaxValue - fMinValue) / 10.,

1874

0);

1875

1876

if (iElementType == CAIRO_DOCK_WIDGET_HSCALE_DOUBLE)

1877

{

1878

pOneWidget = gtk_hscale_new (GTK_ADJUSTMENT (pAdjustment));

1879

gtk_scale_set_digits (GTK_SCALE (pOneWidget), 3);

1880

gtk_widget_set (pOneWidget, "width-request", 150, NULL);

1881

1882

_pack_hscale (pOneWidget);

1883

}

1884

else

1885

{

1886

pOneWidget = gtk_spin_button_new (GTK_ADJUSTMENT (pAdjustment),

1887

1.,

1888

3);

1889

_pack_subwidget (pOneWidget);

1890

}

1891

g_object_set (pAdjustment, "lower", fMinValue, "upper", fMaxValue, NULL); // le 'width-request' sur un GtkHScale avec 'fMinValue' non nul plante ! Donc on les met apres...

1892

gtk_adjustment_set_value (GTK_ADJUSTMENT (pAdjustment), fValue);

1893

}

1894

bAddBackButton = TRUE,

1895

g_free (fValueList);

1896

break;

1897

1898

case CAIRO_DOCK_WIDGET_COLOR_SELECTOR_RGB : // float x3 avec un bouton de choix de couleur.

1899

case CAIRO_DOCK_WIDGET_COLOR_SELECTOR_RGBA : // float x4 avec un bouton de choix de couleur.

1900

iNbElements = (iElementType == CAIRO_DOCK_WIDGET_COLOR_SELECTOR_RGB ? 3 : 4);

1901

length = 0;

1902

fValueList = g_key_file_get_double_list (pKeyFile, cGroupName, cKeyName, &length, NULL);

1903

if (length > 2)

1904

{

1905

gdkColor.red = fValueList[0] * 65535;

1906

gdkColor.green = fValueList[1] * 65535;

1907

gdkColor.blue = fValueList[2] * 65535;

1908

}

1909

pOneWidget = gtk_color_button_new_with_color (&gdkColor);

1910

if (iElementType == CAIRO_DOCK_WIDGET_COLOR_SELECTOR_RGBA)

1911

{

1912

gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (pOneWidget), TRUE);

1913

if (length > 3)

1914

gtk_color_button_set_alpha (GTK_COLOR_BUTTON (pOneWidget), fValueList[3] * 65535);

1915

else

1916

gtk_color_button_set_alpha (GTK_COLOR_BUTTON (pOneWidget), 65535);

1917

}

1918

else

1919

gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (pOneWidget), FALSE);

1920

_pack_subwidget (pOneWidget);

1921

bAddBackButton = TRUE,

1922

g_free (fValueList);

1923

break;

1924

1925

case CAIRO_DOCK_WIDGET_VIEW_LIST : // liste des vues.

1926

_add_combo_from_modele (s_pRendererListStore, TRUE, FALSE);

1927

break ;

1928

1929

case CAIRO_DOCK_WIDGET_THEME_LIST : // liste les themes dans combo, avec prevue et readme.

1930

case CAIRO_DOCK_WIDGET_THEME_LIST_ENTRY : // idem mais avec une combo-entry.

1931

//\______________ On construit le widget de visualisation de themes.

1932

modele = _allocate_new_model ();

1933

gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (modele), CAIRO_DOCK_MODEL_RESULT, GTK_SORT_ASCENDING);

1934

1935

_add_combo_from_modele (modele, TRUE, iElementType == CAIRO_DOCK_WIDGET_THEME_LIST_ENTRY);

1936

1937

//\______________ On recupere les themes.

1938

if (pAuthorizedValuesList != NULL)

1939

{

1940

gchar *cShareThemesDir = NULL, *cUserThemesDir = NULL, *cDistantThemesDir = NULL;

1941

if (pAuthorizedValuesList[0] != NULL)

1942

{

1943

cShareThemesDir = (*pAuthorizedValuesList[0] != '\0' ? cairo_dock_generate_file_path (pAuthorizedValuesList[0]) : NULL); // on autorise les ~/blabla.

1944

if (pAuthorizedValuesList[1] != NULL)

1945

{

1946

cUserThemesDir = g_strdup_printf ("%s/%s/%s", g_cCairoDockDataDir, CAIRO_DOCK_EXTRAS_DIR, pAuthorizedValuesList[1]);

1947

cDistantThemesDir = pAuthorizedValuesList[2];

1948

}

1949

}

1950

cairo_dock_set_status_message_printf (pMainWindow, _("Listing themes in '%s' ..."), cDistantThemesDir);

1951

_allocate_new_buffer;

1952

data[0] = pOneWidget;

1953

data[1] = pMainWindow;

1954

data[2] = g_key_file_get_string (pKeyFile, cGroupName, cKeyName, NULL);

1955

CairoDockTask *pTask = cairo_dock_list_themes_async (cShareThemesDir, cUserThemesDir, cDistantThemesDir, (GFunc) _got_themes_combo_list, data);

1956

g_object_set_data (G_OBJECT (pOneWidget), "cd-task", pTask);

1957

g_signal_connect (pMainWindow, "delete-event", G_CALLBACK (on_delete_async_widget), pOneWidget);

1958

g_object_ref (pOneWidget); // on prend une reference pour que le widget reste en vie lorsqu'on recharge la fenetre (sinon le widget serait detruit sans que la fenetre ne le soit, et lors de la destruction de celle-ci, le signal delete-event serait emis, et la callback appelee avec un widget deja detruit).

1959

g_free (cUserThemesDir);

1960

g_free (cShareThemesDir);

1961

}

1962

break ;

1963

1964

case CAIRO_DOCK_WIDGET_USER_THEME_SELECTOR : // liste des themes utilisateurs, avec une encoche a cote (pour suppression).

1965

//\______________ On construit le treeview des themes.

1966

modele = _allocate_new_model ();

1967

gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (modele), CAIRO_DOCK_MODEL_NAME, GTK_SORT_ASCENDING);

1968

pOneWidget = gtk_tree_view_new ();

1969

gtk_tree_view_set_model (GTK_TREE_VIEW (pOneWidget), GTK_TREE_MODEL (modele));

1970

gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (pOneWidget), FALSE);

1971

1972

rend = gtk_cell_renderer_toggle_new ();

1973

gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (pOneWidget), -1, NULL, rend, "active", CAIRO_DOCK_MODEL_ACTIVE, NULL);

1974

g_signal_connect (G_OBJECT (rend), "toggled", (GCallback) _cairo_dock_activate_one_element, modele);

1975

1976

rend = gtk_cell_renderer_text_new ();

1977

gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (pOneWidget), -1, NULL, rend, "text", CAIRO_DOCK_MODEL_NAME, NULL);

1978

1979

selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pOneWidget));

1980

gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);

1981

1982

pScrolledWindow = gtk_scrolled_window_new (NULL, NULL);

1983

gtk_widget_set (pScrolledWindow, "height-request", 100, NULL);

1984

gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (pScrolledWindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

1985

gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (pScrolledWindow), pOneWidget);

1986

pSubWidgetList = g_slist_append (pSubWidgetList, pOneWidget);

1987

_pack_in_widget_box (pScrolledWindow);

1988

1989

//\______________ On recupere les themes utilisateurs.

1990

if (pAuthorizedValuesList != NULL && pAuthorizedValuesList[0] != NULL && *pAuthorizedValuesList[0] != '\0')

1991

{

1992

gchar *cUserThemesDir = g_strdup_printf ("%s/%s/%s", g_cCairoDockDataDir, CAIRO_DOCK_EXTRAS_DIR, pAuthorizedValuesList[0]);

1993

GHashTable *pThemeTable = cairo_dock_list_themes (NULL, cUserThemesDir, NULL);

1994

g_free (cUserThemesDir);

1995

1996

g_hash_table_foreach (pThemeTable, (GHFunc)_cairo_dock_fill_modele_with_themes, modele);

1997

g_hash_table_destroy (pThemeTable);

1998

}

1999

break ;

2000

2001

case CAIRO_DOCK_WIDGET_ANIMATION_LIST : // liste des animations.

2002

_add_combo_from_modele (s_pAnimationsListStore, FALSE, FALSE);

2003

break ;

2004

2005

case CAIRO_DOCK_WIDGET_DIALOG_DECORATOR_LIST : // liste des decorateurs de dialogue.

2006

_add_combo_from_modele (s_pDialogDecoratorListStore, FALSE, FALSE);

2007

break ;

2008

2009

case CAIRO_DOCK_WIDGET_DESKLET_DECORATION_LIST : // liste des decorations de desklet.

2010

case CAIRO_DOCK_WIDGET_DESKLET_DECORATION_LIST_WITH_DEFAULT : // idem mais avec le choix "defaut" en plus.

2011

{

2012

_add_combo_from_modele ((iElementType == CAIRO_DOCK_WIDGET_DESKLET_DECORATION_LIST ? s_pDecorationsListStore : s_pDecorationsListStore2), FALSE, FALSE);

2013

2014

_allocate_new_buffer;

2015

data[0] = pKeyBox;

2016

data[1] = pFrameVBox != NULL ? pFrameVBox : pGroupBox;

2017

iNbControlledWidgets = 9;

2018

data[2] = GINT_TO_POINTER (iNbControlledWidgets);

2019

iNbControlledWidgets --; // car dans cette fonction, on ne compte pas le separateur.

2020

g_signal_connect (G_OBJECT (pOneWidget), "changed", G_CALLBACK (_cairo_dock_select_custom_item_in_combo), data);

2021

2022

GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (pOneWidget));

2023

GtkTreeIter iter;

2024

if (pOneWidget && gtk_combo_box_get_active_iter (GTK_COMBO_BOX (pOneWidget), &iter))

2025

{

2026

gchar *cName = NULL;

2027

gtk_tree_model_get (model, &iter,

2028

CAIRO_DOCK_MODEL_RESULT, &cName, -1);

2029

if (! cName || strcmp (cName, "personnal") != 0)

2030

{

2031

iNbSensitiveWidgets = 0;

2032

iFirstSensitiveWidget = 1;

2033

pControlContainer = pFrameVBox != NULL ? pFrameVBox : pGroupBox;

2034

}

2035

else

2036

iNbControlledWidgets = 0;

2037

g_free (cName);

2038

}

2039

}

2040

break ;

2041

2042

case CAIRO_DOCK_WIDGET_GAUGE_LIST : // liste des themes de jauge.

2043

if (s_pGaugeListStore == NULL)

2044

{

2045

GHashTable *pGaugeTable = cairo_dock_list_available_gauges ();

2046

cairo_dock_build_gauge_list_for_gui (pGaugeTable);

2047

g_hash_table_destroy (pGaugeTable);

2048

}

2049

_add_combo_from_modele (s_pGaugeListStore, FALSE, FALSE);

2050

break ;

2051

2052

case CAIRO_DOCK_WIDGET_DOCK_LIST : // liste des docks existant.

2053

cairo_dock_build_dock_list_for_gui ();

2054

modele = s_pDocksListStore;

2055

pOneWidget = gtk_combo_box_entry_new_with_model (GTK_TREE_MODEL (modele), CAIRO_DOCK_MODEL_NAME);

2056

2057

cValue = g_key_file_get_string (pKeyFile, cGroupName, cKeyName, NULL);

2058

GtkTreeIter iter;

2059

if (_cairo_dock_find_iter_from_name (modele, cValue, &iter, FALSE))

2060

gtk_combo_box_set_active_iter (GTK_COMBO_BOX (pOneWidget), &iter);

2061

g_free (cValue);

2062

2063

_pack_subwidget (pOneWidget);

2064

break ;

2065

2066

case CAIRO_DOCK_WIDGET_ICON_THEME_LIST :

2067

{

2068

gchar *cUserPath = g_strdup_printf ("%s/.icons", g_getenv ("HOME"));

2069

const gchar *path[3];

2070

path[0] = (const gchar *)cUserPath;

2071

path[1] = "/usr/share/icons";

2072

path[2] = NULL;

2073

2074

if (s_pIconThemeListStore != NULL)

2075

{

2076

gtk_list_store_clear (s_pIconThemeListStore);

2077

s_pIconThemeListStore = NULL;

2078

}

2079

2080

GHashTable *pHashTable = _cairo_dock_build_icon_themes_list (path);

2081

g_free (cUserPath);

2082

2083

cairo_dock_build_icon_theme_list_for_gui (pHashTable);

2084

2085

g_hash_table_destroy (pHashTable);

2086

_add_combo_from_modele (s_pIconThemeListStore, FALSE, FALSE);

2087

2088

_pack_subwidget (pOneWidget);

2089

}

2090

break ;

2091

2092

case CAIRO_DOCK_WIDGET_MODULE_LIST :

2093

{

2094

//\______________ On remplit un modele avec les modules de la categorie.

2095

int iCategory = -1;

2096

if (pAuthorizedValuesList && pAuthorizedValuesList[0] != NULL)

2097

iCategory = atoi (pAuthorizedValuesList[0]);

2098

modele = _allocate_new_model ();

2099

gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (modele), CAIRO_DOCK_MODEL_NAME, GTK_SORT_ASCENDING);

2100

_allocate_new_buffer;

2101

data[0] = GINT_TO_POINTER (iCategory);

2102

data[1] = modele;

2103

cairo_dock_foreach_module ((GHRFunc) _add_module_to_modele, data);

2104

2105

//\______________ On construit le treeview des modules.

2106

gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (modele), CAIRO_DOCK_MODEL_NAME, GTK_SORT_ASCENDING);

2107

pOneWidget = gtk_tree_view_new ();

2108

gtk_tree_view_set_model (GTK_TREE_VIEW (pOneWidget), GTK_TREE_MODEL (modele));

2109

gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (pOneWidget), TRUE);

2110

gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW (pOneWidget), TRUE);

2111

GtkTreeViewColumn* col;

2112

// case a cocher

2113

rend = gtk_cell_renderer_toggle_new ();

2114

col = gtk_tree_view_column_new_with_attributes (NULL, rend, "active", CAIRO_DOCK_MODEL_ACTIVE, NULL);

2115

gtk_tree_view_column_set_sort_column_id (col, CAIRO_DOCK_MODEL_ACTIVE);

2116

gtk_tree_view_append_column (GTK_TREE_VIEW (pOneWidget), col);

2117

g_signal_connect (G_OBJECT (rend), "toggled", (GCallback) _cairo_dock_activate_one_module, modele);

2118

// icone

2119

rend = gtk_cell_renderer_pixbuf_new ();

2120

gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (pOneWidget), -1, NULL, rend, "pixbuf", CAIRO_DOCK_MODEL_ICON, NULL);

2121

// nom

2122

rend = gtk_cell_renderer_text_new ();

2123

col = gtk_tree_view_column_new_with_attributes (_("module"), rend, "text", CAIRO_DOCK_MODEL_NAME, NULL);

2124

gtk_tree_view_column_set_cell_data_func (col, rend, (GtkTreeCellDataFunc)_cairo_dock_render_module_name, NULL, NULL);

2125

gtk_tree_view_column_set_sort_column_id (col, CAIRO_DOCK_MODEL_NAME);

2126

gtk_tree_view_append_column (GTK_TREE_VIEW (pOneWidget), col);

2127

// categorie

2128

rend = gtk_cell_renderer_text_new ();

2129

col = gtk_tree_view_column_new_with_attributes (_("category"), rend, "text", CAIRO_DOCK_MODEL_STATE, NULL);

2130

gtk_tree_view_column_set_cell_data_func (col, rend, (GtkTreeCellDataFunc)_cairo_dock_render_category, NULL, NULL);

2131

gtk_tree_view_column_set_sort_column_id (col, CAIRO_DOCK_MODEL_STATE);

2132

gtk_tree_view_append_column (GTK_TREE_VIEW (pOneWidget), col);

2133

2134

selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pOneWidget));

2135

gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);

2136

2137

pScrolledWindow = gtk_scrolled_window_new (NULL, NULL);

2138

gtk_widget_set (pScrolledWindow, "height-request", 2*CAIRO_DOCK_PREVIEW_HEIGHT, NULL);

2139

gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (pScrolledWindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

2140

gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (pScrolledWindow), pOneWidget);

2141

pSubWidgetList = g_slist_append (pSubWidgetList, pOneWidget);

2142

_pack_in_widget_box (pScrolledWindow);

2143

2144

//\______________ On construit le widget de prevue et on le rajoute a la suite.

2145

pDescriptionLabel = gtk_label_new (NULL);

2146

g_signal_connect (pMainWindow, "delete-event", G_CALLBACK (on_delete_async_widget), pDescriptionLabel);

2147

g_object_ref (pDescriptionLabel);

2148

gtk_label_set_use_markup (GTK_LABEL (pDescriptionLabel), TRUE);

2149

gtk_widget_set (pDescriptionLabel,

2150

"width-request", CAIRO_DOCK_PREVIEW_WIDTH, NULL);

2151

gtk_label_set_justify (GTK_LABEL (pDescriptionLabel), GTK_JUSTIFY_LEFT);

2152

gtk_label_set_line_wrap (GTK_LABEL (pDescriptionLabel), TRUE);

2153

pPreviewImage = gtk_image_new_from_pixbuf (NULL);

2154

g_signal_connect (pMainWindow, "delete-event", G_CALLBACK (on_delete_async_widget), pPreviewImage);

2155

g_object_ref (pPreviewImage);

2156

gtk_widget_set (pPreviewImage,

2157

"height-request", CAIRO_DOCK_PREVIEW_HEIGHT,

2158

"width-request", CAIRO_DOCK_PREVIEW_WIDTH, NULL);

2159

_allocate_new_buffer;

2160

data[0] = pDescriptionLabel;

2161

data[1] = pPreviewImage;

2162

gtk_tree_selection_set_select_function (selection,

2163

(GtkTreeSelectionFunc) _cairo_dock_select_one_item_in_tree,

2164

data,

2165

NULL);

2166

pPreviewBox = gtk_vbox_new (FALSE, CAIRO_DOCK_GUI_MARGIN);

2167

gtk_box_pack_start (GTK_BOX (pPreviewBox), pPreviewImage, FALSE, FALSE, 0);

2168

gtk_box_pack_start (GTK_BOX (pPreviewBox), pDescriptionLabel, FALSE, FALSE, 0);

2169

_pack_in_widget_box (pPreviewBox);

2170

2171

//\______________ On affiche un message par defaut.

2172

gchar *cDefaultMessage = g_strdup_printf ("%s", _("Click on an applet in order to have a preview and a description of it."));

2173

gtk_label_set_markup (GTK_LABEL (pDescriptionLabel), cDefaultMessage);

2174

g_free (cDefaultMessage);

2175

_set_preview_image (CAIRO_DOCK_SHARE_DATA_DIR"/"CAIRO_DOCK_LOGO, GTK_IMAGE (pPreviewImage));

2176

}

2177

break ;

2178

2179

case CAIRO_DOCK_WIDGET_JUMP_TO_MODULE : // bouton raccourci vers un autre module

2180

case CAIRO_DOCK_WIDGET_JUMP_TO_MODULE_IF_EXISTS : // idem mais seulement affiche si le module existe.

2181

if (pAuthorizedValuesList == NULL || pAuthorizedValuesList[0] == NULL || *pAuthorizedValuesList[0] == '\0')

2182

break ;

2183

2184

const gchar *cModuleName = NULL;

2185

CairoDockInternalModule *pInternalModule = cairo_dock_find_internal_module_from_name (pAuthorizedValuesList[0]);

2186

if (pInternalModule != NULL)

2187

cModuleName = pInternalModule->cModuleName;

2188

else

2189

{

2190

CairoDockModule *pModule = cairo_dock_find_module_from_name (pAuthorizedValuesList[0]);

2191

if (pModule != NULL)

2192

cModuleName = pModule->pVisitCard->cModuleName;

2193

else

2194

{

2195

if (iElementType == CAIRO_DOCK_WIDGET_JUMP_TO_MODULE_IF_EXISTS)

2196

{

2197

gtk_widget_set_sensitive (pLabel, FALSE);

2198

break ;

2199

}

2200

cd_warning ("module '%s' not found", pAuthorizedValuesList[0]);

2201

cModuleName = g_strdup (pAuthorizedValuesList[0]); // petite fuite memoire dans ce cas tres rare ...

2202

}

2203

}

2204

pOneWidget = gtk_button_new_from_stock (GTK_STOCK_JUMP_TO);

2205

_allocate_new_buffer;

2206

data[0] = pOneWidget;

2207

data[1] = pMainWindow;

2208

data[2] = cModuleName;

2209

g_signal_connect (G_OBJECT (pOneWidget),

2210

"clicked",

2211

G_CALLBACK (_cairo_dock_configure_module),

2212

data);

2213

_pack_subwidget (pOneWidget);

2214

break ;

2215

2216

case CAIRO_DOCK_WIDGET_LIST : // a list of strings.

2217

case CAIRO_DOCK_WIDGET_NUMBERED_LIST : // a list of numbered strings.

2218

case CAIRO_DOCK_WIDGET_NUMBERED_CONTROL_LIST : // a list of numbered strings whose current choice defines the sensitivity of the widgets below.

2219

case CAIRO_DOCK_WIDGET_NUMBERED_CONTROL_LIST_SELECTIVE : // a list of numbered strings whose current choice defines the sensitivity of the widgets below given in the list.

2220

case CAIRO_DOCK_WIDGET_LIST_WITH_ENTRY : // a list of strings with possibility to select a non-existing one.

2221

if ((iElementType == CAIRO_DOCK_WIDGET_NUMBERED_CONTROL_LIST || iElementType == CAIRO_DOCK_WIDGET_NUMBERED_CONTROL_LIST_SELECTIVE) && pAuthorizedValuesList == NULL)

2222

{

2223

pControlContainer = NULL;

2224

iNbControlledWidgets = 0;

2225

break;

2226

}

2227

cValue = g_key_file_get_locale_string (pKeyFile, cGroupName, cKeyName, NULL, NULL); // nous permet de recuperer les ';' aussi.

2228

// on construit la combo.

2229

modele = _allocate_new_model ();

2230

if (iElementType == CAIRO_DOCK_WIDGET_LIST_WITH_ENTRY)

2231

{

2232

pOneWidget = gtk_combo_box_entry_new_with_model (GTK_TREE_MODEL (modele), CAIRO_DOCK_MODEL_NAME);

2233

}

2234

else

2235

{

2236

pOneWidget = gtk_combo_box_new_with_model (GTK_TREE_MODEL (modele));

2237

rend = gtk_cell_renderer_text_new ();

2238

gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (pOneWidget), rend, FALSE);

2239

gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (pOneWidget), rend, "text", CAIRO_DOCK_MODEL_NAME, NULL);

2240

}

2241

2242

// on la remplit.

2243

if (pAuthorizedValuesList != NULL)

2244

{

2245

k = 0;

2246

int iSelectedItem = -1, iOrder1, iOrder2;

2247

gboolean bNumberedList = (iElementType == CAIRO_DOCK_WIDGET_NUMBERED_LIST || iElementType == CAIRO_DOCK_WIDGET_NUMBERED_CONTROL_LIST || iElementType == CAIRO_DOCK_WIDGET_NUMBERED_CONTROL_LIST_SELECTIVE);

2248

if (bNumberedList)

2249

iSelectedItem = atoi (cValue);

2250

gchar *cResult = (bNumberedList ? g_new0 (gchar , 10) : NULL);

2251

int dk = (iElementType == CAIRO_DOCK_WIDGET_NUMBERED_CONTROL_LIST_SELECTIVE ? 3 : 1);

2252

iNbControlledWidgets = 0;

2253

for (k = 0; pAuthorizedValuesList[k] != NULL; k += dk) // on ajoute toutes les chaines possibles a la combo.

2254

{

2255

GtkTreeIter iter;

2256

gtk_list_store_append (GTK_LIST_STORE (modele), &iter);

2257

if (iSelectedItem == -1 && cValue && strcmp (cValue, pAuthorizedValuesList[k]) == 0)

2258

iSelectedItem = k/dk;

2259

2260

if (cResult != NULL)

2261

snprintf (cResult, 9, "%d", k/dk);

2262

2263

if (iElementType == CAIRO_DOCK_WIDGET_NUMBERED_CONTROL_LIST_SELECTIVE)

2264

{

2265

iOrder1 = atoi (pAuthorizedValuesList[k+1]);

2266

iOrder2 = atoi (pAuthorizedValuesList[k+2]);

2267

iNbControlledWidgets = MAX (iNbControlledWidgets, iOrder1 + iOrder2 - 1);

2268

//g_print ("iSelectedItem:%d ; k/dk:%d\n", iSelectedItem , k/dk);

2269

if (iSelectedItem == k/dk)

2270

{

2271

iFirstSensitiveWidget = iOrder1;

2272

iNbSensitiveWidgets = iOrder2;

2273

}

2274

}

2275

else

2276

{

2277

iOrder1 = iOrder2 = k;

2278

}

2279

gtk_list_store_set (GTK_LIST_STORE (modele), &iter,

2280

CAIRO_DOCK_MODEL_NAME, (bNumberedList ? dgettext (cGettextDomain, pAuthorizedValuesList[k]) : pAuthorizedValuesList[k]),

2281

CAIRO_DOCK_MODEL_RESULT, (cResult != NULL ? cResult : pAuthorizedValuesList[k]),

2282

CAIRO_DOCK_MODEL_ORDER, iOrder1,

2283

CAIRO_DOCK_MODEL_ORDER2, iOrder2, -1);

2284

}

2285

g_free (cResult);

2286

2287

// on active l'element courant.

2288

if (iElementType != CAIRO_DOCK_WIDGET_LIST_WITH_ENTRY && iSelectedItem == -1) // si le choix courant n'etait pas dans la liste, on decide de selectionner le 1er.

2289

iSelectedItem = 0;

2290

if (k != 0) // rien dans le gtktree => plantage.

2291

gtk_combo_box_set_active (GTK_COMBO_BOX (pOneWidget), iSelectedItem);

2292

if (iElementType == CAIRO_DOCK_WIDGET_NUMBERED_CONTROL_LIST || iElementType == CAIRO_DOCK_WIDGET_NUMBERED_CONTROL_LIST_SELECTIVE)

2293

{

2294

pControlContainer = (pFrameVBox != NULL ? pFrameVBox : pGroupBox);

2295

_allocate_new_buffer;

2296

data[0] = pKeyBox;

2297

data[1] = pControlContainer;

2298

if (iElementType == CAIRO_DOCK_WIDGET_NUMBERED_CONTROL_LIST)

2299

{

2300

iNbControlledWidgets = k;

2301

data[2] = GINT_TO_POINTER (iNbControlledWidgets);

2302

g_signal_connect (G_OBJECT (pOneWidget), "changed", G_CALLBACK (_cairo_dock_select_one_item_in_control_combo), data);

2303

iFirstSensitiveWidget = iSelectedItem+1; // on decroit jusqu'a 0.

2304

iNbSensitiveWidgets = 1;

2305

//g_print ("CONTROL : %d,%d,%d\n", iNbControlledWidgets, iFirstSensitiveWidget, iNbSensitiveWidgets);

2306

}

2307

else

2308

{

2309

data[2] = GINT_TO_POINTER (iNbControlledWidgets);

2310

g_signal_connect (G_OBJECT (pOneWidget), "changed", G_CALLBACK (_cairo_dock_select_one_item_in_control_combo_selective), data);

2311

}

2312

//g_print (" pControlContainer:%x\n", pControlContainer);

2313

}

2314

}

2315

_pack_subwidget (pOneWidget);

2316

g_free (cValue);

2317

break ;

2318

2319

case CAIRO_DOCK_WIDGET_TREE_VIEW_SORT : // N strings listed from top to bottom.

2320

case CAIRO_DOCK_WIDGET_TREE_VIEW_SORT_AND_MODIFY : // same with possibility to add/remove some.

2321

case CAIRO_DOCK_WIDGET_TREE_VIEW_MULTI_CHOICE : // N strings that can be selected or not.

2322

// on construit le tree view.

2323

cValueList = g_key_file_get_locale_string_list (pKeyFile, cGroupName, cKeyName, NULL, &length, NULL);

2324

pOneWidget = gtk_tree_view_new ();

2325

modele = _allocate_new_model ();

2326

gtk_tree_view_set_model (GTK_TREE_VIEW (pOneWidget), GTK_TREE_MODEL (modele));

2327

gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (modele), CAIRO_DOCK_MODEL_ORDER, GTK_SORT_ASCENDING);

2328

gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (pOneWidget), FALSE);

2329

2330

if (iElementType == CAIRO_DOCK_WIDGET_TREE_VIEW_MULTI_CHOICE)

2331

{

2332

rend = gtk_cell_renderer_toggle_new ();

2333

gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (pOneWidget), -1, NULL, rend, "active", CAIRO_DOCK_MODEL_ACTIVE, NULL);

2334

g_signal_connect (G_OBJECT (rend), "toggled", (GCallback) _cairo_dock_activate_one_element, modele);

2335

}

2336

2337

rend = gtk_cell_renderer_text_new ();

2338

gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (pOneWidget), -1, NULL, rend, "text", CAIRO_DOCK_MODEL_NAME, NULL);

2339

selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pOneWidget));

2340

gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);

2341

2342

pSubWidgetList = g_slist_append (pSubWidgetList, pOneWidget);

2343

2344

pScrolledWindow = gtk_scrolled_window_new (NULL, NULL);

2345

g_print ("length:%d\n", length);

2346

int k;

2347

if (pAuthorizedValuesList != NULL && pAuthorizedValuesList[0] != NULL)

2348

for (k = 0; pAuthorizedValuesList[k] != NULL; k++);

2349

else

2350

k = 1;

2351

gtk_widget_set (pScrolledWindow, "height-request", (iElementType == CAIRO_DOCK_WIDGET_TREE_VIEW_SORT_AND_MODIFY ? 100 : MIN (100, k * 25)), NULL);

2352

gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (pScrolledWindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

2353

gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (pScrolledWindow), pOneWidget);

2354

_pack_in_widget_box (pScrolledWindow);

2355

2356

if (iElementType != CAIRO_DOCK_WIDGET_TREE_VIEW_MULTI_CHOICE)

2357

{

2358

pSmallVBox = gtk_vbox_new (FALSE, 3);

2359

_pack_in_widget_box (pSmallVBox);

2360

2361

pButtonUp = gtk_button_new_from_stock (GTK_STOCK_GO_UP);

2362

g_signal_connect (G_OBJECT (pButtonUp),

2363

"clicked",

2364

G_CALLBACK (_cairo_dock_go_up),

2365

pOneWidget);

2366

gtk_box_pack_start (GTK_BOX (pSmallVBox),

2367

pButtonUp,

2368

FALSE,

2369

FALSE,

2370

0);

2371

2372

pButtonDown = gtk_button_new_from_stock (GTK_STOCK_GO_DOWN);

2373

g_signal_connect (G_OBJECT (pButtonDown),

2374

"clicked",

2375

G_CALLBACK (_cairo_dock_go_down),

2376

pOneWidget);

2377

gtk_box_pack_start (GTK_BOX (pSmallVBox),

2378

pButtonDown,

2379

FALSE,

2380

FALSE,

2381

0);

2382

}

2383

2384

if (iElementType == CAIRO_DOCK_WIDGET_TREE_VIEW_SORT_AND_MODIFY)

2385

{

2386

pTable = gtk_table_new (2, 2, FALSE);

2387

_pack_in_widget_box (pTable);

2388

2389

_allocate_new_buffer;

2390

2391

pButtonAdd = gtk_button_new_from_stock (GTK_STOCK_ADD);

2392

g_signal_connect (G_OBJECT (pButtonAdd),

2393

"clicked",

2394

G_CALLBACK (_cairo_dock_add),

2395

data);

2396

gtk_table_attach (GTK_TABLE (pTable),

2397

pButtonAdd,

2398

0, 1,

2399

0, 1,

2400

GTK_SHRINK, GTK_SHRINK,

2401

0, 0);

2402

pButtonRemove = gtk_button_new_from_stock (GTK_STOCK_REMOVE);

2403

g_signal_connect (G_OBJECT (pButtonRemove),

2404

"clicked",

2405

G_CALLBACK (_cairo_dock_remove),

2406

data);

2407

gtk_table_attach (GTK_TABLE (pTable),

2408

pButtonRemove,

2409

0, 1,

2410

1, 2,

2411

GTK_SHRINK, GTK_SHRINK,

2412

0, 0);

2413

pEntry = gtk_entry_new ();

2414

gtk_table_attach (GTK_TABLE (pTable),

2415

pEntry,

2416

1, 2,

2417

0, 2,

2418

GTK_SHRINK, GTK_SHRINK,

2419

0, 0);

2420

2421

data[0] = pOneWidget;

2422

data[1] = pEntry;

2423

}

2424

2425

// on le remplit.

2426

if (iElementType == CAIRO_DOCK_WIDGET_TREE_VIEW_SORT_AND_MODIFY) // on liste les choix actuels tout simplement.

2427

{

2428

for (k = 0; k < length; k ++)

2429

{

2430

cValue = cValueList[k];

2431

if (cValue != NULL) // paranoia.

2432

{

2433

memset (&iter, 0, sizeof (GtkTreeIter));

2434

gtk_list_store_append (modele, &iter);

2435

gtk_list_store_set (modele, &iter,

2436

CAIRO_DOCK_MODEL_ACTIVE, TRUE,

2437

CAIRO_DOCK_MODEL_NAME, cValue,

2438

CAIRO_DOCK_MODEL_RESULT, cValue,

2439

CAIRO_DOCK_MODEL_ORDER, k, -1);

2440

}

2441

}

2442

}

2443

else if (pAuthorizedValuesList != NULL) // on liste les choix possibles dans l'ordre choisi. Pour CAIRO_DOCK_WIDGET_TREE_VIEW_MULTI_CHOICE, on complete avec ceux n'ayant pas ete selectionnes.

2444

{

2445

gint iNbPossibleValues = 0, iOrder = 0;

2446

while (pAuthorizedValuesList[iNbPossibleValues] != NULL)

2447

iNbPossibleValues ++;

2448

guint l;

2449

for (l = 0; l < length; l ++)

2450

{

2451

cValue = cValueList[l];

2452

if (! g_ascii_isdigit (*cValue)) // ancien format.

2453

{

2454

g_print ("old format\n");

2455

int k;

2456

for (k = 0; k < iNbPossibleValues; k ++) // on cherche la correspondance.

2457

{

2458

if (strcmp (cValue, pAuthorizedValuesList[k]) == 0)

2459

{

2460

g_print (" correspondance %s <-> %d\n", cValue, k);

2461

g_free (cValueList[l]);

2462

cValueList[l] = g_strdup_printf ("%d", k);

2463

cValue = cValueList[l];

2464

break ;

2465

}

2466

}

2467

if (k < iNbPossibleValues)

2468

iValue = k;

2469

else

2470

continue;

2471

}

2472

else

2473

iValue = atoi (cValue);

2474

2475

if (iValue < iNbPossibleValues)

2476

{

2477

memset (&iter, 0, sizeof (GtkTreeIter));

2478

gtk_list_store_append (modele, &iter);

2479

gtk_list_store_set (modele, &iter,

2480

CAIRO_DOCK_MODEL_ACTIVE, TRUE,

2481

CAIRO_DOCK_MODEL_NAME, dgettext (cGettextDomain, pAuthorizedValuesList[iValue]),

2482

CAIRO_DOCK_MODEL_RESULT, cValue,

2483

CAIRO_DOCK_MODEL_ORDER, iOrder ++, -1);

2484

}

2485

}

2486

2487

if (iOrder < iNbPossibleValues) // il reste des valeurs a inserer (ce peut etre de nouvelles valeurs apparues lors d'une maj du fichier de conf, donc CAIRO_DOCK_WIDGET_TREE_VIEW_SORT est concerne aussi).

2488

{

2489

gchar cResult[10];

2490

for (k = 0; pAuthorizedValuesList[k] != NULL; k ++)

2491

{

2492

cValue = pAuthorizedValuesList[k];

2493

for (l = 0; l < length; l ++)

2494

{

2495

iValue = atoi (cValueList[l]);

2496

if (iValue == k) // a deja ete inseree.

2497

break;

2498

}

2499

2500

if (l == length) // elle n'a pas encore ete inseree.

2501

{

2502

snprintf (cResult, 9, "%d", k);

2503

memset (&iter, 0, sizeof (GtkTreeIter));

2504

gtk_list_store_append (modele, &iter);

2505

gtk_list_store_set (modele, &iter,

2506

CAIRO_DOCK_MODEL_ACTIVE, (iElementType == CAIRO_DOCK_WIDGET_TREE_VIEW_SORT),

2507

CAIRO_DOCK_MODEL_NAME, dgettext (cGettextDomain, cValue),

2508

CAIRO_DOCK_MODEL_RESULT, cResult,

2509

CAIRO_DOCK_MODEL_ORDER, iOrder ++, -1);

2510

}

2511

}

2512

}

2513

}

2514

break ;

2515

2516

case CAIRO_DOCK_WIDGET_THEME_SELECTOR : // tree view with 4 sortable columns.

2517

//\______________ On construit le treeview des themes.

2518

modele = _allocate_new_model ();

2519

gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (modele), CAIRO_DOCK_MODEL_NAME, GTK_SORT_ASCENDING);

2520

pOneWidget = gtk_tree_view_new ();

2521

gtk_tree_view_set_model (GTK_TREE_VIEW (pOneWidget), GTK_TREE_MODEL (modele));

2522

gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (pOneWidget), TRUE);

2523

gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW (pOneWidget), TRUE);

2524

selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pOneWidget));

2525

gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);

2526

g_object_set_data (G_OBJECT (pOneWidget), "get-active-line-only", GINT_TO_POINTER (1));

2527

GtkTreeViewColumn* col;

2528

// etat

2529

rend = gtk_cell_renderer_text_new ();

2530

col = gtk_tree_view_column_new_with_attributes (_("state"), rend, "text", CAIRO_DOCK_MODEL_STATE, NULL);

2531

gtk_tree_view_column_set_sort_column_id (col, CAIRO_DOCK_MODEL_STATE);

2532

gtk_tree_view_column_set_cell_data_func (col, rend, (GtkTreeCellDataFunc)_cairo_dock_render_state, NULL, NULL);

2533

gtk_tree_view_append_column (GTK_TREE_VIEW (pOneWidget), col);

2534

// nom du theme

2535

rend = gtk_cell_renderer_text_new ();

2536

col = gtk_tree_view_column_new_with_attributes (_("theme"), rend, "text", CAIRO_DOCK_MODEL_NAME, NULL);

2537

gtk_tree_view_column_set_sort_column_id (col, CAIRO_DOCK_MODEL_NAME);

2538

gtk_tree_view_append_column (GTK_TREE_VIEW (pOneWidget), col);

2539

// note

2540

GtkListStore *note_list = _make_note_list_store ();

2541

rend = gtk_cell_renderer_combo_new ();

2542

g_object_set (G_OBJECT (rend),

2543

"text-column", 1,

2544

"model", note_list,

2545

"has-entry", FALSE,

2546

"editable", TRUE,

2547

NULL);

2548

g_signal_connect (G_OBJECT (rend), "edited", (GCallback) _change_rating, modele);

2549

col = gtk_tree_view_column_new_with_attributes (_("rating"), rend, "text", CAIRO_DOCK_MODEL_ORDER, NULL);

2550

gtk_tree_view_column_set_sort_column_id (col, CAIRO_DOCK_MODEL_ORDER);

2551

gtk_tree_view_column_set_cell_data_func (col, rend, (GtkTreeCellDataFunc)_cairo_dock_render_rating, NULL, NULL);

2552

gtk_tree_view_append_column (GTK_TREE_VIEW (pOneWidget), col);

2553

// sobriete

2554

rend = gtk_cell_renderer_text_new ();

2555

col = gtk_tree_view_column_new_with_attributes (_("sobriety"), rend, "text", CAIRO_DOCK_MODEL_ORDER2, NULL);

2556

gtk_tree_view_column_set_sort_column_id (col, CAIRO_DOCK_MODEL_ORDER2);

2557

gtk_tree_view_column_set_cell_data_func (col, rend, (GtkTreeCellDataFunc)_cairo_dock_render_sobriety, NULL, NULL);

2558

gtk_tree_view_append_column (GTK_TREE_VIEW (pOneWidget), col);

2559

// barres de defilement

2560

GtkObject *adj = gtk_adjustment_new (0., 0., 100., 1, 10, 10);

2561

gtk_tree_view_set_vadjustment (GTK_TREE_VIEW (pOneWidget), GTK_ADJUSTMENT (adj));

2562

pScrolledWindow = gtk_scrolled_window_new (NULL, NULL);

2563

gtk_widget_set (pScrolledWindow, "height-request", CAIRO_DOCK_PREVIEW_HEIGHT+20, NULL); // prevue + readme.

2564

gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (pScrolledWindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

2565

gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (pScrolledWindow), pOneWidget);

2566

pSubWidgetList = g_slist_append (pSubWidgetList, pOneWidget);

2567

_pack_in_widget_box (pScrolledWindow);

2568

2569

//\______________ On construit le widget de prevue et on le rajoute a la suite.

2570

pDescriptionLabel = gtk_label_new (NULL);

2571

g_signal_connect (pMainWindow, "delete-event", G_CALLBACK (on_delete_async_widget), pDescriptionLabel);

2572

g_object_ref (pDescriptionLabel);

2573

gtk_label_set_use_markup (GTK_LABEL (pDescriptionLabel), TRUE);

2574

gtk_widget_set (pDescriptionLabel,

2575

"width-request", CAIRO_DOCK_PREVIEW_WIDTH, NULL);

2576

gtk_label_set_justify (GTK_LABEL (pDescriptionLabel), GTK_JUSTIFY_LEFT);

2577

gtk_label_set_line_wrap (GTK_LABEL (pDescriptionLabel), TRUE);

2578

pPreviewImage = gtk_image_new_from_pixbuf (NULL);

2579

g_signal_connect (pMainWindow, "delete-event", G_CALLBACK (on_delete_async_widget), pPreviewImage);

2580

g_object_ref (pPreviewImage);

2581

gtk_widget_set (pPreviewImage,

2582

"height-request", CAIRO_DOCK_PREVIEW_HEIGHT,

2583

"width-request", CAIRO_DOCK_PREVIEW_WIDTH, NULL);

2584

_allocate_new_buffer;

2585

data[0] = pDescriptionLabel;

2586

data[1] = pPreviewImage;

2587

gtk_tree_selection_set_select_function (selection,

2588

(GtkTreeSelectionFunc) _cairo_dock_select_one_item_in_tree,

2589

data,

2590

NULL);

2591

pPreviewBox = gtk_vbox_new (FALSE, CAIRO_DOCK_GUI_MARGIN);

2592

gtk_box_pack_start (GTK_BOX (pPreviewBox), pPreviewImage, FALSE, FALSE, 0);

2593

gtk_box_pack_start (GTK_BOX (pPreviewBox), pDescriptionLabel, FALSE, FALSE, 0);

2594

_pack_in_widget_box (pPreviewBox);

2595

2596

//\______________ On recupere les themes.

2597

if (pAuthorizedValuesList != NULL)

2598

{

2599

gchar *cShareThemesDir = NULL, *cUserThemesDir = NULL, *cDistantThemesDir = NULL;

2600

if (pAuthorizedValuesList[0] != NULL)

2601

{

2602

cShareThemesDir = (*pAuthorizedValuesList[0] != '\0' ? pAuthorizedValuesList[0] : NULL);

2603

if (pAuthorizedValuesList[1] != NULL)

2604

{

2605

cUserThemesDir = g_strdup_printf ("%s/%s/%s", g_cCairoDockDataDir, CAIRO_DOCK_EXTRAS_DIR, pAuthorizedValuesList[1]);

2606

cDistantThemesDir = pAuthorizedValuesList[2];

2607

}

2608

}

2609

2610

_allocate_new_buffer;

2611

data[0] = pOneWidget;

2612

data[1] = pMainWindow;

2613

CairoDockTask *pTask = cairo_dock_list_themes_async (cShareThemesDir, cUserThemesDir, cDistantThemesDir, (GFunc) _got_themes_list, data);

2614

g_object_set_data (G_OBJECT (pOneWidget), "cd-task", pTask);

2615

g_signal_connect (pMainWindow, "delete-event", G_CALLBACK (on_delete_async_widget), pOneWidget);

2616

g_object_ref (pOneWidget);

2617

/**GHashTable *pThemeTable = cairo_dock_list_themes (cShareThemesDir, cUserThemesDir, cDistantThemesDir);

2618

g_hash_table_foreach (pThemeTable, (GHFunc)_cairo_dock_fill_modele_with_themes, modele);

2619

g_hash_table_destroy (pThemeTable);*/

2620

g_free (cUserThemesDir);

2621

}

2622

break ;

2623

2624

case 'r' : // deprecated.

2625

cd_warning ("\nTHIS CONF FILE IS OUT OF DATE\n");

2626

break ;

2627

2628

case CAIRO_DOCK_WIDGET_FONT_SELECTOR : // string avec un selecteur de font a cote du GtkEntry.

2629

cValue = g_key_file_get_string (pKeyFile, cGroupName, cKeyName, NULL);

2630

pOneWidget = gtk_font_button_new_with_font (cValue);

2631

gtk_font_button_set_show_style (GTK_FONT_BUTTON (pOneWidget), TRUE);

2632

gtk_font_button_set_show_size (GTK_FONT_BUTTON (pOneWidget), TRUE);

2633

gtk_font_button_set_use_size (GTK_FONT_BUTTON (pOneWidget), TRUE);

2634

gtk_font_button_set_use_font (GTK_FONT_BUTTON (pOneWidget), TRUE);

2635

_pack_subwidget (pOneWidget);

2636

g_free (cValue);

2637

break;

2638

2639

case CAIRO_DOCK_WIDGET_LINK : // string avec un lien internet a cote.

2640

cValue = g_key_file_get_string (pKeyFile, cGroupName, cKeyName, NULL);

2641

pOneWidget = gtk_link_button_new_with_label (cValue, pAuthorizedValuesList && pAuthorizedValuesList[0] ? pAuthorizedValuesList[0] : _("link"));

2642

_pack_subwidget (pOneWidget);

2643

g_free (cValue);

2644

break;

2645

2646

2647

case CAIRO_DOCK_WIDGET_STRING_ENTRY : // string (Merci Fab !) :-P

2648

case CAIRO_DOCK_WIDGET_PASSWORD_ENTRY : // string de type "password", crypte dans le .conf et cache dans l'UI (Merci Tofe !) :-)

2649

case CAIRO_DOCK_WIDGET_FILE_SELECTOR : // string avec un selecteur de fichier a cote du GtkEntry.

2650

case CAIRO_DOCK_WIDGET_FOLDER_SELECTOR : // string avec un selecteur de repertoire a cote du GtkEntry.

2651

case CAIRO_DOCK_WIDGET_SOUND_SELECTOR : // string avec un selecteur de fichier a cote du GtkEntry et un boutton play.

2652

case CAIRO_DOCK_WIDGET_SHORTKEY_SELECTOR : // string avec un selecteur de touche clavier (Merci Ctaf !)

2653

case CAIRO_DOCK_WIDGET_CLASS_SELECTOR : // string avec un selecteur de class (Merci Matttbe !)

2654

// on construit l'entree de texte.

2655

cValue = g_key_file_get_locale_string (pKeyFile, cGroupName, cKeyName, NULL, NULL); // nous permet de recuperer les ';' aussi.

2656

pOneWidget = gtk_entry_new ();

2657

pEntry = pOneWidget;

2658

if( iElementType == CAIRO_DOCK_WIDGET_PASSWORD_ENTRY ) // on cache le texte entre et on decrypte 'cValue'.

2659

{

2660

gtk_entry_set_visibility (GTK_ENTRY (pOneWidget), FALSE);

2661

gchar *cDecryptedString = NULL;

2662

cairo_dock_decrypt_string ( cValue, &cDecryptedString );

2663

g_free (cValue);

2664

cValue = cDecryptedString;

2665

}

2666

gtk_entry_set_text (GTK_ENTRY (pOneWidget), cValue);

2667

_pack_subwidget (pOneWidget);

2668

2669

// on ajoute des boutons qui la rempliront.

2670

if (iElementType == CAIRO_DOCK_WIDGET_FILE_SELECTOR || iElementType == CAIRO_DOCK_WIDGET_FOLDER_SELECTOR || iElementType == CAIRO_DOCK_WIDGET_SOUND_SELECTOR) // on ajoute un selecteur de fichier.

2671

{

2672

_allocate_new_buffer;

2673

data[0] = pEntry;

2674

data[1] = GINT_TO_POINTER (iElementType != CAIRO_DOCK_WIDGET_SOUND_SELECTOR ? (iElementType == CAIRO_DOCK_WIDGET_FILE_SELECTOR ? 0 : 1) : 0);

2675

data[2] = pMainWindow;

2676

pButtonFileChooser = gtk_button_new_from_stock (GTK_STOCK_OPEN);

2677

g_signal_connect (G_OBJECT (pButtonFileChooser),

2678

"clicked",

2679

G_CALLBACK (_cairo_dock_pick_a_file),

2680

data);

2681

_pack_in_widget_box (pButtonFileChooser);

2682

if (iElementType == CAIRO_DOCK_WIDGET_SOUND_SELECTOR) //Sound Play Button

2683

{

2684

pButtonPlay = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PLAY); //Outch

2685

g_signal_connect (G_OBJECT (pButtonPlay),

2686

"clicked",

2687

G_CALLBACK (_cairo_dock_play_a_sound),

2688

data);

2689

_pack_in_widget_box (pButtonPlay);

2690

}

2691

}

2692

else if (iElementType == CAIRO_DOCK_WIDGET_SHORTKEY_SELECTOR || iElementType == CAIRO_DOCK_WIDGET_CLASS_SELECTOR) // on ajoute un selecteur de touches/classe.

2693

{

2694

GtkWidget *pGrabKeyButton = gtk_button_new_with_label(_("grab"));

2695

_allocate_new_buffer;

2696

data[0] = pOneWidget;

2697

data[1] = pMainWindow;

2698

gtk_widget_add_events(pMainWindow, GDK_KEY_PRESS_MASK);

2699

if (iElementType == CAIRO_DOCK_WIDGET_CLASS_SELECTOR)

2700

{

2701

g_signal_connect (G_OBJECT (pGrabKeyButton),

2702

"clicked",

2703

G_CALLBACK (_cairo_dock_key_grab_class),

2704

data);

2705

}

2706

else

2707

{

2708

g_signal_connect (G_OBJECT (pGrabKeyButton),

2709

"clicked",

2710

G_CALLBACK (_cairo_dock_key_grab_clicked),

2711

data);

2712

}

2713

_pack_in_widget_box (pGrabKeyButton);

2714

}

2715

g_free (cValue);

2716

break;

2717

2718

case CAIRO_DOCK_WIDGET_EMPTY_WIDGET : // container pour widget personnalise.

2719

pOneWidget = gtk_hbox_new (0, FALSE);

2720

pSubWidgetList = g_slist_append (pSubWidgetList, pOneWidget);

2721

gtk_box_pack_start(GTK_BOX (pFrameVBox != NULL ? pFrameVBox : pGroupBox),

2722

pOneWidget,

2723

FALSE,

2724

FALSE,

2725

0);

2726

break ;

2727

2728

case CAIRO_DOCK_WIDGET_TEXT_LABEL : // juste le label de texte.

2729

break ;

2730

2731

case CAIRO_DOCK_WIDGET_HANDBOOK : // le label contenant le manuel de l'applet, il a ete place avant.

2732

cValue = g_key_file_get_string (pKeyFile, cGroupName, cKeyName, NULL);

2733

CairoDockModule *pModule = cairo_dock_find_module_from_name (cValue);

2734

if (pModule == NULL)

2735

break;

2736

2737

int iPreviewWidth, iPreviewHeight;

2738

GdkPixbuf *pPreviewPixbuf = NULL;

2739

int w=200, h=200;

2740

if (gdk_pixbuf_get_file_info (pModule->pVisitCard->cPreviewFilePath, &iPreviewWidth, &iPreviewHeight) != NULL) // The return value is owned by GdkPixbuf and should not be freed.

2741

{

2742

if (iPreviewWidth > w)

2743

{

2744

iPreviewHeight *= 1.*w/iPreviewWidth;

2745

iPreviewWidth = w;

2746

}

2747

if (iPreviewHeight > h)

2748

{

2749

iPreviewWidth *= 1.*h/iPreviewHeight;

2750

iPreviewHeight = h;

2751

}

2752

pPreviewPixbuf = gdk_pixbuf_new_from_file_at_size (pModule->pVisitCard->cPreviewFilePath, iPreviewWidth, iPreviewHeight, NULL);

2753

}

2754

if (pPreviewPixbuf != NULL)

2755

{

2756

pPreviewImage = gtk_image_new_from_pixbuf (NULL);

2757

gtk_image_set_from_pixbuf (GTK_IMAGE (pPreviewImage), pPreviewPixbuf);

2758

gdk_pixbuf_unref (pPreviewPixbuf);

2759

_pack_in_widget_box (pPreviewImage);

2760

}

2761

break ;

2762

2763

case CAIRO_DOCK_WIDGET_FRAME : // frame.

2764

case CAIRO_DOCK_WIDGET_EXPANDER : // frame dans un expander.

2765

if (pAuthorizedValuesList == NULL)

2766

{

2767

pFrame = NULL;

2768

pFrameVBox = NULL;

2769

}

2770

else

2771

{

2772

if (pAuthorizedValuesList[0] == NULL || *pAuthorizedValuesList[0] == '\0')

2773

cValue = g_key_file_get_string (pKeyFile, cGroupName, cKeyName, NULL); // utile ?

2774

else

2775

{

2776

cValue = pAuthorizedValuesList[0];

2777

cSmallIcon = pAuthorizedValuesList[1];

2778

}

2779

2780

gchar *cFrameTitle = g_strdup_printf ("%s", dgettext (cGettextDomain, cValue));

2781

pLabel= gtk_label_new (NULL);

2782

gtk_label_set_markup (GTK_LABEL (pLabel), cFrameTitle);

2783

g_free (cFrameTitle);

2784

2785

pLabelContainer = NULL;

2786

if (cSmallIcon != NULL)

2787

{

2788

pLabelContainer = gtk_hbox_new (FALSE, CAIRO_DOCK_ICON_MARGIN/2);

2789

GtkWidget *pImage = gtk_image_new ();

2790

GdkPixbuf *pixbuf;

2791

if (*cSmallIcon != '/')

2792

pixbuf = gtk_widget_render_icon (pImage,

2793

cSmallIcon ,

2794

GTK_ICON_SIZE_MENU,

2795

NULL);

2796

else

2797

pixbuf = gdk_pixbuf_new_from_file_at_size (cSmallIcon, CAIRO_DOCK_FRAME_ICON_SIZE, CAIRO_DOCK_FRAME_ICON_SIZE, NULL);

2798

if (pixbuf != NULL)

2799

{

2800

gtk_image_set_from_pixbuf (GTK_IMAGE (pImage), pixbuf);

2801

gdk_pixbuf_unref (pixbuf);

2802

}

2803

gtk_container_add (GTK_CONTAINER (pLabelContainer),

2804

pImage);

2805

2806

gtk_container_add (GTK_CONTAINER (pLabelContainer),

2807

pLabel);

2808

}

2809

2810

GtkWidget *pExternFrame;

2811

if (iElementType == CAIRO_DOCK_WIDGET_FRAME)

2812

{

2813

pExternFrame = gtk_frame_new (NULL);

2814

gtk_container_set_border_width (GTK_CONTAINER (pExternFrame), CAIRO_DOCK_GUI_MARGIN);

2815

gtk_frame_set_shadow_type (GTK_FRAME (pExternFrame), GTK_SHADOW_OUT);

2816

gtk_frame_set_label_widget (GTK_FRAME (pExternFrame), (pLabelContainer != NULL ? pLabelContainer : pLabel));

2817

pFrame = pExternFrame;

2818

//g_print ("on met pLabelContainer:%x (%x > %x)\n", pLabelContainer, gtk_frame_get_label_widget (GTK_FRAME (pFrame)), pLabel);

2819

}

2820

else

2821

{

2822

pExternFrame = gtk_expander_new (NULL);

2823

gtk_expander_set_expanded (GTK_EXPANDER (pExternFrame), FALSE);

2824

gtk_expander_set_label_widget (GTK_EXPANDER (pExternFrame), (pLabelContainer != NULL ? pLabelContainer : pLabel));

2825

pFrame = gtk_frame_new (NULL);

2826

gtk_container_set_border_width (GTK_CONTAINER (pFrame), CAIRO_DOCK_GUI_MARGIN);

2827

gtk_frame_set_shadow_type (GTK_FRAME (pFrame), GTK_SHADOW_OUT);

2828

gtk_container_add (GTK_CONTAINER (pExternFrame),

2829

pFrame);

2830

}

2831

//pSubWidgetList = g_slist_append (pSubWidgetList, pExternFrame);

2832

2833

gtk_box_pack_start (GTK_BOX (pGroupBox),

2834

pExternFrame,

2835

FALSE,

2836

FALSE,

2837

0);

2838

2839

pFrameVBox = gtk_vbox_new (FALSE, CAIRO_DOCK_GUI_MARGIN);

2840

gtk_container_add (GTK_CONTAINER (pFrame),

2841

pFrameVBox);

2842

2843

if (pAuthorizedValuesList[0] == NULL || *pAuthorizedValuesList[0] == '\0')

2844

g_free (cValue);

2845

2846

2847

if (iNbControlledWidgets > 0 && pControlContainer != NULL)

2848

{

2849

g_print ("ctrl\n");

2850

if (pControlContainer == pGroupBox)

2851

{

2852

g_print ("ctrl (iNbControlledWidgets:%d, iFirstSensitiveWidget:%d, iNbSensitiveWidgets:%d)\n", iNbControlledWidgets, iFirstSensitiveWidget, iNbSensitiveWidgets);

2853

iNbControlledWidgets --;

2854

if (iFirstSensitiveWidget > 0)

2855

iFirstSensitiveWidget --;

2856

2857

GtkWidget *w = pExternFrame;

2858

if (iFirstSensitiveWidget == 0 && iNbSensitiveWidgets > 0)

2859

{

2860

g_print (" => sensitive\n");

2861

iNbSensitiveWidgets --;

2862

if (GTK_IS_EXPANDER (w))

2863

gtk_expander_set_expanded (GTK_EXPANDER (w), TRUE);

2864

}

2865

else

2866

{

2867

g_print (" => unsensitive\n");

2868

if (!GTK_IS_EXPANDER (w))

2869

gtk_widget_set_sensitive (w, FALSE);

2870

}

2871

}

2872

}

2873

}

2874

break;

2875

2876

case CAIRO_DOCK_WIDGET_SEPARATOR : // separateur.

2877

{

2878

GtkWidget *pAlign = gtk_alignment_new (.5, 0., 0.8, 0.);

2879

pOneWidget = gtk_hseparator_new ();

2880

gtk_container_add (GTK_CONTAINER (pAlign), pOneWidget);

2881

gtk_box_pack_start (GTK_BOX (pFrameVBox != NULL ? pFrameVBox : pGroupBox),

2882

pAlign,

2883

FALSE,

2884

FALSE,

2885

0);

2886

}

2887

break ;

2888

2889

default :

2890

cd_warning ("this conf file has an unknown widget type ! (%c)", iElementType);

2891

break ;

2892

}

2893

2894

if (pSubWidgetList != NULL)

2895

{

2896

pGroupKeyWidget = g_new (gpointer, 6);

2897

pGroupKeyWidget[0] = g_strdup (cGroupName); // car on ne pourra pas le liberer s'il est partage entre plusieurs 'data'.

2898

pGroupKeyWidget[1] = cKeyName;

2899

pGroupKeyWidget[2] = pSubWidgetList;

2900

pGroupKeyWidget[3] = (gchar *)cOriginalConfFilePath;

2901

pGroupKeyWidget[4] = pLabel;

2902

pGroupKeyWidget[5] = pKeyBox; // on ne peut pas remonter a la keybox a partir du label a cause du cas particulier des widgets a prevue.

2903

*pWidgetList = g_slist_prepend (*pWidgetList, pGroupKeyWidget);

2904

if (bAddBackButton && cOriginalConfFilePath != NULL)

2905

{

2906

pBackButton = gtk_button_new ();

2907

GtkWidget *pImage = gtk_image_new_from_stock (GTK_STOCK_CLEAR, GTK_ICON_SIZE_MENU); // gtk_image_new_from_stock (GTK_STOCK_UNDO, GTK_ICON_SIZE_BUTTON);

2908

gtk_button_set_image (GTK_BUTTON (pBackButton), pImage);

2909

g_signal_connect (G_OBJECT (pBackButton), "clicked", G_CALLBACK(_cairo_dock_set_original_value), pGroupKeyWidget);

2910

_pack_in_widget_box (pBackButton);

2911

}

2912

}

2913

2914

if (pAuthorizedValuesList != NULL)

2915

g_strfreev (pAuthorizedValuesList);

2916

g_free (cKeyComment);

2917

}

2918

g_free (cGroupComment); // cSmallGroupIcon et cDisplayedGroupName pointaient dessus.

2919

g_free (pKeyList); // on libere juste la liste de chaines, pas les chaines a l'interieur.

2920

2921

if (iNbControlledWidgets > 0)

2922

cd_warning ("this conf file has an invalid combo list somewhere !");

2923

2924

return pGroupBox;

2925

}

2926

2927

2928

GtkWidget *cairo_dock_build_key_file_widget (GKeyFile* pKeyFile, const gchar *cGettextDomain, GtkWidget *pMainWindow, GSList **pWidgetList, GPtrArray *pDataGarbage, const gchar *cOriginalConfFilePath)

2929

{

2930

gsize length = 0;

2931

gchar **pGroupList = g_key_file_get_groups (pKeyFile, &length);

2932

g_return_val_if_fail (pGroupList != NULL, NULL);

2933

2934

GtkWidget *pNoteBook = gtk_notebook_new ();

2935

gtk_notebook_set_scrollable (GTK_NOTEBOOK (pNoteBook), TRUE);

2936

gtk_notebook_popup_enable (GTK_NOTEBOOK (pNoteBook));

2937

g_object_set (G_OBJECT (pNoteBook), "tab-pos", GTK_POS_TOP, NULL);

2938

2939

GtkWidget *pGroupWidget, *pLabel, *pLabelContainer, *pAlign;

2940

gchar *cGroupName, *cGroupComment, *cIcon;

2941

int iCategory, i = 0;

2942

while (pGroupList[i] != NULL)

2943

{

2944

cGroupName = pGroupList[i];

2945

2946

//\____________ On recupere les caracteristiques du groupe.

2947

cGroupComment = g_key_file_get_comment (pKeyFile, cGroupName, NULL, NULL);

2948

iCategory = 0;

2949

cIcon = NULL;

2950

if (cGroupComment != NULL)

2951

{

2952

cGroupComment[strlen(cGroupComment)-1] = '\0';

2953

gchar *ptr = cGroupComment;

2954

if (*ptr == '!')

2955

{

2956

ptr = strrchr (cGroupComment, '\n');

2957

if (ptr != NULL)

2958

ptr ++;

2959

else

2960

ptr = cGroupComment;

2961

}

2962

if (*ptr == '[')

2963

ptr ++;

2964

2965

gchar *str = strchr (ptr, ';');

2966

if (str != NULL)

2967

{

2968

*str = '\0';

2969

if (*(str-1) == ']')

2970

*(str-1) = '\0';

2971

2972

cIcon = ptr;

2973

ptr = str+1;

2974

2975

str = strchr (ptr, ';');

2976

if (str != NULL)

2977

*str = '\0';

2978

iCategory = atoi (ptr);

2979

}

2980

else

2981

{

2982

if (ptr[strlen(ptr)-1] == ']')

2983

ptr[strlen(ptr)-1] = '\0';

2984

cIcon = ptr;

2985

}

2986

}

2987

2988

//\____________ On construit son widget.

2989

pLabel = gtk_label_new (dgettext (cGettextDomain, cGroupName));

2990

pLabelContainer = NULL;

2991

pAlign = NULL;

2992

if (cIcon != NULL && *cIcon != '\0')

2993

{

2994

pLabelContainer = gtk_hbox_new (FALSE, CAIRO_DOCK_ICON_MARGIN);

2995

pAlign = gtk_alignment_new (0., 0.5, 0., 0.);

2996

gtk_container_add (GTK_CONTAINER (pAlign), pLabelContainer);

2997

2998

GtkWidget *pImage = gtk_image_new ();

2999

GdkPixbuf *pixbuf;

3000

if (*cIcon != '/')

3001

pixbuf = gtk_widget_render_icon (pImage,

3002

cIcon ,

3003

GTK_ICON_SIZE_BUTTON,

3004

NULL);

3005

else

3006

pixbuf = gdk_pixbuf_new_from_file_at_size (cIcon, CAIRO_DOCK_TAB_ICON_SIZE, CAIRO_DOCK_TAB_ICON_SIZE, NULL);

3007

if (pixbuf != NULL)

3008

{

3009

gtk_image_set_from_pixbuf (GTK_IMAGE (pImage), pixbuf);

3010

gdk_pixbuf_unref (pixbuf);

3011

}

3012

gtk_container_add (GTK_CONTAINER (pLabelContainer),

3013

pImage);

3014

gtk_container_add (GTK_CONTAINER (pLabelContainer), pLabel);

3015

gtk_widget_show_all (pLabelContainer);

3016

}

3017

g_free (cGroupComment);

3018

3019

pGroupWidget = cairo_dock_build_group_widget (pKeyFile, cGroupName, cGettextDomain, pMainWindow, pWidgetList, pDataGarbage, cOriginalConfFilePath);

3020

3021

GtkWidget *pScrolledWindow = gtk_scrolled_window_new (NULL, NULL);

3022

gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (pScrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);

3023

gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (pScrolledWindow), pGroupWidget);

3024

3025

gtk_notebook_append_page (GTK_NOTEBOOK (pNoteBook), pScrolledWindow, (pAlign != NULL ? pAlign : pLabel));

3026

3027

i ++;

3028

}

3029

3030

g_strfreev (pGroupList);

3031

return pNoteBook;

3032

}

3033

3034

GtkWidget *cairo_dock_build_conf_file_widget (const gchar *cConfFilePath, const gchar *cGettextDomain, GtkWidget *pMainWindow, GSList **pWidgetList, GPtrArray *pDataGarbage, const gchar *cOriginalConfFilePath)

3035

{

3036

//\_____________ On recupere les groupes du fichier.

3037

GKeyFile* pKeyFile = cairo_dock_open_key_file (cConfFilePath);

3038

if (pKeyFile == NULL)

3039

return NULL;

3040

3041

//\_____________ On construit le widget.

3042

GtkWidget *pNoteBook = cairo_dock_build_key_file_widget (pKeyFile, cGettextDomain, pMainWindow, pWidgetList, pDataGarbage, cOriginalConfFilePath);

3043

3044

g_key_file_free (pKeyFile);

3045

return pNoteBook;

3046

}

3047

3048

3049

3050

static gboolean _cairo_dock_get_active_elements (GtkTreeModel * model, GtkTreePath * path, GtkTreeIter * iter, GSList **pStringList)

3051

{

3052

//g_print ("%s ()\n", __func__);

3053

gboolean bActive;

3054

gchar *cValue = NULL, *cResult = NULL;

3055

gtk_tree_model_get (model, iter,

3056

CAIRO_DOCK_MODEL_ACTIVE, &bActive,

3057

CAIRO_DOCK_MODEL_NAME, &cValue,

3058

CAIRO_DOCK_MODEL_RESULT, &cResult, -1);

3059

if (cResult != NULL)

3060

{

3061

g_free (cValue);

3062

cValue = cResult;

3063

}

3064

3065

if (bActive)

3066

{

3067

*pStringList = g_slist_append (*pStringList, cValue);

3068

}

3069

else

3070

{

3071

g_free (cValue);

3072

}

3073

return FALSE;

3074

}

3075

static void _cairo_dock_get_each_widget_value (gpointer *data, GKeyFile *pKeyFile)

3076

{

3077

gchar *cGroupName = data[0];

3078

gchar *cKeyName = data[1];

3079

GSList *pSubWidgetList = data[2];

3080

if (pSubWidgetList == NULL)

3081

return ;

3082

GSList *pList;

3083

gsize i = 0, iNbElements = g_slist_length (pSubWidgetList);

3084

GtkWidget *pOneWidget = pSubWidgetList->data;

3085

3086

if (GTK_IS_CHECK_BUTTON (pOneWidget))

3087

{

3088

gboolean *tBooleanValues = g_new0 (gboolean, iNbElements);

3089

for (pList = pSubWidgetList; pList != NULL; pList = pList->next)

3090

{

3091

pOneWidget = pList->data;

3092

tBooleanValues[i] = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pOneWidget));

3093

i ++;

3094

}

3095

if (iNbElements > 1)

3096

g_key_file_set_boolean_list (pKeyFile, cGroupName, cKeyName, tBooleanValues, iNbElements);

3097

else

3098

g_key_file_set_boolean (pKeyFile, cGroupName, cKeyName, tBooleanValues[0]);

3099

g_free (tBooleanValues);

3100

}

3101

else if (GTK_IS_SPIN_BUTTON (pOneWidget) || GTK_IS_HSCALE (pOneWidget))

3102

{

3103

gboolean bIsSpin = GTK_IS_SPIN_BUTTON (pOneWidget);

3104

3105

if ((bIsSpin && gtk_spin_button_get_digits (GTK_SPIN_BUTTON (pOneWidget)) == 0) || (! bIsSpin && gtk_scale_get_digits (GTK_SCALE (pOneWidget)) == 0))

3106

{

3107

int *tIntegerValues = g_new0 (int, iNbElements);

3108

for (pList = pSubWidgetList; pList != NULL; pList = pList->next)

3109

{

3110

pOneWidget = pList->data;

3111

tIntegerValues[i] = (bIsSpin ? gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pOneWidget)) : gtk_range_get_value (GTK_RANGE (pOneWidget)));

3112

i ++;

3113

}

3114

if (iNbElements > 1)

3115

g_key_file_set_integer_list (pKeyFile, cGroupName, cKeyName, tIntegerValues, iNbElements);

3116

else

3117

g_key_file_set_integer (pKeyFile, cGroupName, cKeyName, tIntegerValues[0]);

3118

g_free (tIntegerValues);

3119

}

3120

else

3121

{

3122

double *tDoubleValues = g_new0 (double, iNbElements);

3123

for (pList = pSubWidgetList; pList != NULL; pList = pList->next)

3124

{

3125

pOneWidget = pList->data;

3126

tDoubleValues[i] = (bIsSpin ? gtk_spin_button_get_value (GTK_SPIN_BUTTON (pOneWidget)) : gtk_range_get_value (GTK_RANGE (pOneWidget)));

3127

i ++;

3128

}

3129

if (iNbElements > 1)

3130

g_key_file_set_double_list (pKeyFile, cGroupName, cKeyName, tDoubleValues, iNbElements);

3131

else

3132

g_key_file_set_double (pKeyFile, cGroupName, cKeyName, tDoubleValues[0]);

3133

g_free (tDoubleValues);

3134

}

3135

}

3136

else if (GTK_IS_COMBO_BOX (pOneWidget))

3137

{

3138

GtkTreeIter iter;

3139

gchar *cValue = NULL;

3140

if (GTK_IS_COMBO_BOX_ENTRY (pOneWidget))

3141

{

3142

cValue = gtk_combo_box_get_active_text (GTK_COMBO_BOX (pOneWidget));

3143

}

3144

else if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (pOneWidget), &iter))

3145

{

3146

GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (pOneWidget));

3147

if (model != NULL)

3148

gtk_tree_model_get (model, &iter, CAIRO_DOCK_MODEL_RESULT, &cValue, -1);

3149

}

3150

g_key_file_set_string (pKeyFile, cGroupName, cKeyName, (cValue != NULL ? cValue : ""));

3151

g_free (cValue);

3152

}

3153

else if (GTK_IS_FONT_BUTTON (pOneWidget))

3154

{

3155

const gchar *cFontName = gtk_font_button_get_font_name (GTK_FONT_BUTTON (pOneWidget));

3156

g_key_file_set_string (pKeyFile, cGroupName, cKeyName, cFontName);

3157

}

3158

else if (GTK_IS_COLOR_BUTTON (pOneWidget))

3159

{

3160

GdkColor gdkColor;

3161

gtk_color_button_get_color (GTK_COLOR_BUTTON (pOneWidget), &gdkColor);

3162

double col[4];

3163

int iNbColors;

3164

col[0] = (double) gdkColor.red / 65535.;

3165

col[1] = (double) gdkColor.green / 65535.;

3166

col[2] = (double) gdkColor.blue / 65535.;

3167

if (gtk_color_button_get_use_alpha (GTK_COLOR_BUTTON (pOneWidget)))

3168

{

3169

iNbColors = 4;

3170

col[3] = (double) gtk_color_button_get_alpha (GTK_COLOR_BUTTON (pOneWidget)) / 65535.;

3171

}

3172

else

3173

{

3174

iNbColors = 3;

3175

}

3176

g_key_file_set_double_list (pKeyFile, cGroupName, cKeyName, col, iNbColors);

3177

}

3178

else if (GTK_IS_ENTRY (pOneWidget))

3179

{

3180

gchar *cValue = NULL;

3181

const gchar *cWidgetValue = gtk_entry_get_text (GTK_ENTRY (pOneWidget));

3182

if( !gtk_entry_get_visibility(GTK_ENTRY (pOneWidget)) )

3183

{

3184

cairo_dock_encrypt_string( cWidgetValue, &cValue );

3185

}

3186

else

3187

{

3188

cValue = g_strdup (cWidgetValue);

3189

}

3190

const gchar* const * cPossibleLocales = g_get_language_names ();

3191

gchar *cKeyNameFull, *cTranslatedValue;

3192

// g_key_file_set_locale_string ne marche pas avec une locale NULL comme le fait 'g_key_file_get_locale_string', il faut donc le faire a la main !

3193

3194

for (i = 0; cPossibleLocales[i] != NULL; i++)

3195

{

3196

cKeyNameFull = g_strdup_printf ("%s[%s]", cKeyName, cPossibleLocales[i]);

3197

cTranslatedValue = g_key_file_get_string (pKeyFile, cGroupName, cKeyNameFull, NULL);

3198

g_free (cKeyNameFull);

3199

if (cTranslatedValue != NULL && strcmp (cTranslatedValue, "") != 0)

3200

{

3201

g_free (cTranslatedValue);

3202

break;

3203

}

3204

g_free (cTranslatedValue);

3205

}

3206

if (cPossibleLocales[i] != NULL)

3207

g_key_file_set_locale_string (pKeyFile, cGroupName, cKeyName, cPossibleLocales[i], cValue);

3208

else

3209

g_key_file_set_string (pKeyFile, cGroupName, cKeyName, cValue);

3210

3211

g_free( cValue );

3212

}

3213

else if (GTK_IS_TREE_VIEW (pOneWidget))

3214

{

3215

gboolean bGetActiveOnly = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (pOneWidget), "get-active-line-only"));

3216

//g_print ("%s : bGetActiveOnly=%d\n", cKeyName, bGetActiveOnly);

3217

GtkTreeModel *pModel = gtk_tree_view_get_model (GTK_TREE_VIEW (pOneWidget));

3218

gchar **tStringValues = NULL;

3219

3220

if (bGetActiveOnly)

3221

{

3222

GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pOneWidget));

3223

GList *pRows = gtk_tree_selection_get_selected_rows (selection, NULL);

3224

iNbElements = g_list_length (pRows);

3225

tStringValues = g_new0 (gchar *, iNbElements + 1);

3226

3227

i = 0;

3228

GList *r;

3229

GtkTreePath *cPath;

3230

for (r = pRows; r != NULL; r = r->next)

3231

{

3232

cPath = r->data;

3233

GtkTreeIter iter;

3234

if (! gtk_tree_model_get_iter (pModel, &iter, cPath))

3235

continue;

3236

3237

gchar *cName = NULL;

3238

gtk_tree_model_get (pModel, &iter, CAIRO_DOCK_MODEL_RESULT, &cName, -1);

3239

tStringValues[i++] = cName;

3240

}

3241

iNbElements = i;

3242

}

3243

else

3244

{

3245

GSList *pActiveElementList = NULL;

3246

gtk_tree_model_foreach (GTK_TREE_MODEL (pModel), (GtkTreeModelForeachFunc) _cairo_dock_get_active_elements, &pActiveElementList);

3247

iNbElements = g_slist_length (pActiveElementList);

3248

tStringValues = g_new0 (gchar *, iNbElements + 1);

3249

3250

i = 0;

3251

GSList * pListElement;

3252

for (pListElement = pActiveElementList; pListElement != NULL; pListElement = pListElement->next)

3253

{

3254

//g_print (" %d) %s\n", i, pListElement->data);

3255

tStringValues[i++] = pListElement->data;

3256

}

3257

g_slist_free (pActiveElementList); // ses donnees sont dans 'tStringValues' et seront donc liberees avec.

3258

}

3259

if (iNbElements > 1)

3260

g_key_file_set_string_list (pKeyFile, cGroupName, cKeyName, (const gchar * const *)tStringValues, iNbElements);

3261

else

3262

g_key_file_set_string (pKeyFile, cGroupName, cKeyName, (tStringValues[0] != NULL ? tStringValues[0] : ""));

3263

g_strfreev (tStringValues);

3264

}

3265

}

3266

void cairo_dock_update_keyfile_from_widget_list (GKeyFile *pKeyFile, GSList *pWidgetList)

3267

{

3268

g_slist_foreach (pWidgetList, (GFunc) _cairo_dock_get_each_widget_value, pKeyFile);

3269

}

3270

3271

3272

3273

static void _cairo_dock_free_widget_list (gpointer *data, gpointer user_data)

3274

{

3275

cd_debug ("");

3276

g_free (data[0]);

3277

g_free (data[1]);

3278

g_slist_free (data[2]); // les elements de data[2] sont les widgets, et se feront liberer lors de la destruction de la fenetre.

3279

}

3280

void cairo_dock_free_generated_widget_list (GSList *pWidgetList)

3281

{

3282

g_slist_foreach (pWidgetList, (GFunc) _cairo_dock_free_widget_list, NULL);

3283

g_slist_free (pWidgetList);

3284

}

3285

3286

3287

static int _cairo_dock_find_widget_from_name (gpointer *data, gpointer *pUserData)

3288

{

3289

gchar *cWantedGroupName = pUserData[0];

3290

gchar *cWantedKeyName = pUserData[1];

3291

3292

gchar *cGroupName = data[0];

3293

gchar *cKeyName = data[1];

3294

3295

if (strcmp (cGroupName, cWantedGroupName) == 0 && strcmp (cKeyName, cWantedKeyName) == 0)

3296

return 0;

3297

else

3298

return 1;

3299

}

3300

GSList *cairo_dock_find_widgets_from_name (GSList *pWidgetList, const gchar *cGroupName, const gchar *cKeyName)

3301

{

3302

const gchar *data[2] = {cGroupName, cKeyName};

3303

GSList *pElement = g_slist_find_custom (pWidgetList, data, (GCompareFunc) _cairo_dock_find_widget_from_name);

3304

if (pElement == NULL)

3305

return NULL;

3306

3307

gpointer *pWidgetData = pElement->data;

3308

GSList *pSubWidgetList = pWidgetData[2];

3309

return pSubWidgetList;

3310

}

3311

GtkWidget *cairo_dock_find_widget_from_name (GSList *pWidgetList, const gchar *cGroupName, const gchar *cKeyName)

3312

{

3313

GSList *pSubWidgetList = cairo_dock_find_widgets_from_name (pWidgetList, cGroupName, cKeyName);

3314

g_return_val_if_fail (pSubWidgetList != NULL, NULL);

3315

return pSubWidgetList->data;

3316

}

3317

3318

3319

void cairo_dock_fill_combo_with_themes (GtkWidget *pCombo, GHashTable *pThemeTable, gchar *cActiveTheme)

3320

{

3321

GtkTreeModel *modele = gtk_combo_box_get_model (GTK_COMBO_BOX (pCombo));

3322

g_return_if_fail (modele != NULL);

3323

g_hash_table_foreach (pThemeTable, (GHFunc)_cairo_dock_fill_modele_with_short_themes, modele);

3324

3325

GtkTreeIter iter;

3326

cairo_dock_extract_theme_type_from_name (cActiveTheme);

3327

if (_cairo_dock_find_iter_from_name (GTK_LIST_STORE (modele), cActiveTheme, &iter, TRUE))

3328

{

3329

gtk_combo_box_set_active_iter (GTK_COMBO_BOX (pCombo), &iter);

3330

gboolean bReturn;

3331

g_signal_emit_by_name (pCombo, "changed", NULL, &bReturn);

3332

g_print ("%s found \n", cActiveTheme);

3333

}

3334

}

3335

3336

void cairo_dock_fill_combo_with_list (GtkWidget *pCombo, GList *pElementList, const gchar *cActiveElement)

3337

{

3338

GtkTreeModel *pModele = gtk_combo_box_get_model (GTK_COMBO_BOX (pCombo));

3339

g_return_if_fail (pModele != NULL);

3340

3341

GtkTreeIter iter;

3342

GList *l;

3343

for (l = pElementList; l != NULL; l = l->next)

3344

{

3345

gchar *cElement = l->data;

3346

memset (&iter, 0, sizeof (GtkTreeIter));

3347

gtk_list_store_append (GTK_LIST_STORE (pModele), &iter);

3348

gtk_list_store_set (GTK_LIST_STORE (pModele), &iter,

3349

CAIRO_DOCK_MODEL_NAME, cElement,

3350

CAIRO_DOCK_MODEL_RESULT, cElement,

3351

CAIRO_DOCK_MODEL_DESCRIPTION_FILE, "none",

3352

CAIRO_DOCK_MODEL_IMAGE, "none", -1);

3353

}

3354

3355

if (cActiveElement != NULL && _cairo_dock_find_iter_from_name (GTK_LIST_STORE (pModele), cActiveElement, &iter, FALSE))

3356

gtk_combo_box_set_active_iter (GTK_COMBO_BOX (pCombo), &iter);

3357

}

Older »