~kalgasnik/lightdm-gtk-greeter/lp-1377743-indicator-services-restart-after-every-resume : revision 287

55

56

#include <lightdm.h>

57

58

#include <src/lightdm-gtk-greeter-ui.h>

58

#include "src/greetermenubar.h"

59

#include "src/lightdm-gtk-greeter-ui.h"

59

60

61

#if GTK_CHECK_VERSION (3, 0, 0)

61

62

#include <src/lightdm-gtk-greeter-css-fallback.h>

73

74

75

/* Panel Widgets */

75

76

static GtkWindow *panel_window;

76

static GtkWidget *clock_label;

77

static GtkWidget *menubar, *power_menuitem, *session_menuitem, *language_menuitem, *a11y_menuitem,

77

static GtkWidget *menubar;

78

static GtkWidget *power_menuitem, *session_menuitem, *language_menuitem, *a11y_menuitem,

78

79

*layout_menuitem, *session_badge;

79

80

static GtkWidget *suspend_menuitem, *hibernate_menuitem, *restart_menuitem, *shutdown_menuitem;

80

static GtkWidget *keyboard_menuitem;

81

static GtkWidget *keyboard_menuitem, *clock_menuitem, *clock_label, *host_menuitem;

81

82

static GtkMenu *session_menu, *language_menu, *layout_menu;

82

83

84

/* Login Window Widgets */

164

165

static XklEngine *xkl_engine;

165

166

#endif

166

167

168

typedef enum

169

{

170

PANEL_ITEM_INDICATOR,

171

PANEL_ITEM_SPACER,

172

PANEL_ITEM_SEPARATOR,

173

PANEL_ITEM_TEXT

174

} GreeterPanelItemType;

175

176

#if GTK_CHECK_VERSION (3, 0, 0)

177

static const gchar *PANEL_ITEM_STYLE = "panel-item";

178

static const gchar *PANEL_ITEM_STYLE_HOVERED = "panel-item-hovered";

179

180

static const gchar *PANEL_ITEM_STYLES[] =

181

{

182

"panel-item-indicator",

183

"panel-item-spacer",

184

"panel-item-separator",

185

"panel-item-text"

186

};

187

#endif

188

189

static const gchar *PANEL_ITEM_DATA_INDEX = "panel-item-data-index";

190

191

#ifdef HAVE_LIBINDICATOR

192

static const gchar *INDICATOR_ITEM_DATA_OBJECT = "indicator-item-data-object";

193

static const gchar *INDICATOR_ITEM_DATA_ENTRY = "indicator-item-data-entry";

194

static const gchar *INDICATOR_ITEM_DATA_BOX = "indicator-item-data-box";

195

static const gchar *INDICATOR_DATA_MENUITEMS = "indicator-data-menuitems";

196

#endif

167

197

168

198

static void

169

199

pam_message_finalize (PAMConversationMessage *message)

172

202

g_free (message);

173

203

}

174

204

205

#if GTK_CHECK_VERSION (3, 0, 0)

206

static gboolean

207

panel_item_enter_notify_cb (GtkWidget *widget, GdkEvent *event, gpointer enter)

208

{

209

GtkStyleContext *context = gtk_widget_get_style_context (widget);

210

if (GPOINTER_TO_INT (enter))

211

gtk_style_context_add_class (context, PANEL_ITEM_STYLE_HOVERED);

212

else

213

gtk_style_context_remove_class (context, PANEL_ITEM_STYLE_HOVERED);

214

return FALSE;

215

}

216

#endif

217

175

218

static void

176

add_indicator_to_panel (GtkWidget *indicator_item, gint index)

219

panel_add_item (GtkWidget *widget, gint index, GreeterPanelItemType item_type)

177

220

{

178

221

gint insert_pos = 0;

179

222

GList* items = gtk_container_get_children (GTK_CONTAINER (menubar));

180

223

GList* item;

181

224

for (item = items; item; item = item->next)

182

225

{

183

if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item->data), "indicator-custom-index-data")) < index)

226

if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item->data), PANEL_ITEM_DATA_INDEX)) < index)

184

227

break;

185

228

insert_pos++;

186

229

}

187

230

g_list_free (items);

188

231

189

gtk_menu_shell_insert (GTK_MENU_SHELL (menubar), GTK_WIDGET (indicator_item), insert_pos);

232

#if GTK_CHECK_VERSION (3, 0, 0)

233

gtk_style_context_add_class (gtk_widget_get_style_context (widget), PANEL_ITEM_STYLE);

234

gtk_style_context_add_class (gtk_widget_get_style_context (widget), PANEL_ITEM_STYLES[item_type]);

235

if (item_type == PANEL_ITEM_INDICATOR)

236

{

237

g_signal_connect (G_OBJECT (widget), "enter-notify-event",

238

G_CALLBACK (panel_item_enter_notify_cb), GINT_TO_POINTER(TRUE));

239

g_signal_connect (G_OBJECT (widget), "leave-notify-event",

240

G_CALLBACK (panel_item_enter_notify_cb), GINT_TO_POINTER(FALSE));

241

}

242

#endif

243

244

gtk_widget_show (widget);

245

gtk_menu_shell_insert (GTK_MENU_SHELL (menubar), widget, insert_pos);

190

246

}

191

247

192

248

#ifdef HAVE_LIBINDICATOR

193

249

static gboolean

194

entry_scrolled (GtkWidget *menuitem, GdkEventScroll *event, gpointer data)

250

indicator_entry_scrolled_cb (GtkWidget *menuitem, GdkEventScroll *event, gpointer data)

195

251

{

196

252

IndicatorObject *io;

197

253

IndicatorObjectEntry *entry;

198

254

199

255

g_return_val_if_fail (GTK_IS_WIDGET (menuitem), FALSE);

200

256

201

io = g_object_get_data (G_OBJECT (menuitem), "indicator-custom-object-data");

202

entry = g_object_get_data (G_OBJECT (menuitem), "indicator-custom-entry-data");

257

io = g_object_get_data (G_OBJECT (menuitem), INDICATOR_ITEM_DATA_OBJECT);

258

entry = g_object_get_data (G_OBJECT (menuitem), INDICATOR_ITEM_DATA_ENTRY);

203

259

204

260

g_return_val_if_fail (INDICATOR_IS_OBJECT (io), FALSE);

205

261

210

266

}

211

267

212

268

static void

213

entry_activated (GtkWidget *widget, gpointer user_data)

269

indicator_entry_activated_cb (GtkWidget *widget, gpointer user_data)

214

270

{

215

271

IndicatorObject *io;

216

272

IndicatorObjectEntry *entry;

217

273

218

274

g_return_if_fail (GTK_IS_WIDGET (widget));

219

275

220

io = g_object_get_data (G_OBJECT (widget), "indicator-custom-object-data");

221

entry = g_object_get_data (G_OBJECT (widget), "indicator-custom-entry-data");

276

io = g_object_get_data (G_OBJECT (widget), INDICATOR_ITEM_DATA_OBJECT);

277

entry = g_object_get_data (G_OBJECT (widget), INDICATOR_ITEM_DATA_ENTRY);

222

278

223

279

g_return_if_fail (INDICATOR_IS_OBJECT (io));

224

280

226

282

}

227

283

228

284

static GtkWidget*

229

create_menuitem (IndicatorObject *io, IndicatorObjectEntry *entry, GtkWidget *menubar)

285

indicator_entry_create_menuitem (IndicatorObject *io, IndicatorObjectEntry *entry, GtkWidget *menubar)

230

286

{

231

287

GtkWidget *box, *menuitem;

232

gint index = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (io), "indicator-custom-index-data"));

288

gint index = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (io), PANEL_ITEM_DATA_INDEX));

233

289

234

290

#if GTK_CHECK_VERSION (3, 0, 0)

235

291

box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);

240

296

241

297

gtk_widget_add_events(GTK_WIDGET(menuitem), GDK_SCROLL_MASK);

242

298

243

g_object_set_data (G_OBJECT (menuitem), "indicator-custom-box-data", box);

244

g_object_set_data (G_OBJECT (menuitem), "indicator-custom-object-data", io);

245

g_object_set_data (G_OBJECT (menuitem), "indicator-custom-entry-data", entry);

246

g_object_set_data (G_OBJECT (menuitem), "indicator-custom-index-data", GINT_TO_POINTER (index));

299

g_object_set_data (G_OBJECT (menuitem), INDICATOR_ITEM_DATA_BOX, box);

300

g_object_set_data (G_OBJECT (menuitem), INDICATOR_ITEM_DATA_OBJECT, io);

301

g_object_set_data (G_OBJECT (menuitem), INDICATOR_ITEM_DATA_ENTRY, entry);

302

g_object_set_data (G_OBJECT (menuitem), PANEL_ITEM_DATA_INDEX, GINT_TO_POINTER (index));

247

303

248

g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (entry_activated), NULL);

249

g_signal_connect (G_OBJECT (menuitem), "scroll-event", G_CALLBACK (entry_scrolled), NULL);

304

g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (indicator_entry_activated_cb), NULL);

305

g_signal_connect (G_OBJECT (menuitem), "scroll-event", G_CALLBACK (indicator_entry_scrolled_cb), NULL);

250

306

251

307

if (entry->image)

252

308

gtk_box_pack_start (GTK_BOX(box), GTK_WIDGET(entry->image), FALSE, FALSE, 1);

259

315

260

316

gtk_container_add (GTK_CONTAINER (menuitem), box);

261

317

gtk_widget_show (box);

262

add_indicator_to_panel (menuitem, index);

318

panel_add_item(menuitem, index, PANEL_ITEM_INDICATOR);

263

319

264

320

return menuitem;

265

321

}

266

322

267

323

static void

268

entry_added (IndicatorObject *io, IndicatorObjectEntry *entry, gpointer user_data)

324

indicator_entry_added_cb (IndicatorObject *io, IndicatorObjectEntry *entry, gpointer user_data)

269

325

{

270

326

GHashTable *menuitem_lookup;

271

327

GtkWidget *menuitem;

272

328

273

329

/* if the menuitem doesn't already exist, create it now */

274

menuitem_lookup = g_object_get_data (G_OBJECT (io), "indicator-custom-menuitems-data");

330

menuitem_lookup = g_object_get_data (G_OBJECT (io), INDICATOR_DATA_MENUITEMS);

275

331

g_return_if_fail (menuitem_lookup);

276

332

menuitem = g_hash_table_lookup (menuitem_lookup, entry);

277

333

if (!GTK_IS_WIDGET (menuitem))

278

334

{

279

menuitem = create_menuitem (io, entry, GTK_WIDGET (user_data));

335

menuitem = indicator_entry_create_menuitem (io, entry, GTK_WIDGET (user_data));

280

336

g_hash_table_insert (menuitem_lookup, entry, menuitem);

281

337

}

282

338

284

340

}

285

341

286

342

static void

287

entry_removed_cb (GtkWidget *widget, gpointer userdata)

343

remove_indicator_entry_cb (GtkWidget *widget, gpointer userdata)

288

344

{

289

345

IndicatorObject *io;

290

346

GHashTable *menuitem_lookup;

291

347

GtkWidget *menuitem;

292

348

gpointer entry;

293

349

294

io = g_object_get_data (G_OBJECT (widget), "indicator-custom-object-data");

350

io = g_object_get_data (G_OBJECT (widget), INDICATOR_ITEM_DATA_OBJECT);

295

351

if (!INDICATOR_IS_OBJECT (io))

296

352

return;

297

353

298

entry = g_object_get_data (G_OBJECT (widget), "indicator-custom-entry-data");

354

entry = g_object_get_data (G_OBJECT (widget), INDICATOR_ITEM_DATA_ENTRY);

299

355

if (entry != userdata)

300

356

return;

301

357

302

menuitem_lookup = g_object_get_data (G_OBJECT (io), "indicator-custom-menuitems-data");

358

menuitem_lookup = g_object_get_data (G_OBJECT (io), INDICATOR_DATA_MENUITEMS);

303

359

g_return_if_fail (menuitem_lookup);

304

360

menuitem = g_hash_table_lookup (menuitem_lookup, entry);

305

361

if (GTK_IS_WIDGET (menuitem))

309

365

}

310

366

311

367

static void

312

entry_removed (IndicatorObject *io, IndicatorObjectEntry *entry, gpointer user_data)

368

indicator_entry_removed_cb (IndicatorObject *io, IndicatorObjectEntry *entry, gpointer user_data)

313

369

{

314

gtk_container_foreach (GTK_CONTAINER (user_data), entry_removed_cb, entry);

370

gtk_container_foreach (GTK_CONTAINER (user_data), remove_indicator_entry_cb, entry);

315

371

}

316

372

317

373

static void

318

menu_show (IndicatorObject *io, IndicatorObjectEntry *entry, guint32 timestamp, gpointer user_data)

374

indicator_menu_show_cb (IndicatorObject *io, IndicatorObjectEntry *entry, guint32 timestamp, gpointer user_data)

319

375

{

320

376

IndicatorObjectEntry *entrydata;

321

377

GtkWidget *menuitem;

403

459

GHashTable *builtin_items = NULL;

404

460

GHashTableIter iter;

405

461

gpointer iter_value;

462

#ifdef HAVE_LIBINDICATOR

406

463

gboolean inited = FALSE;

464

#endif

407

465

gboolean fallback = FALSE;

408

466

467

const gchar *DEFAULT_LAYOUT[] = {"~host", "~spacer", "~clock", "~spacer",

468

"~session", "~language", "~a11y", "~power", NULL};

469

409

470

#ifdef START_INDICATOR_SERVICES

410

471

GError *error = NULL;

411

472

gchar *AT_SPI_CMD[] = {"/usr/lib/at-spi2-core/at-spi-bus-launcher", "--launch-immediately", NULL};

423

484

fallback = TRUE;

424

485

}

425

486

426

if (names && !fallback)

487

if (!names || fallback)

427

488

{

428

builtin_items = g_hash_table_new (g_str_hash, g_str_equal);

429

430

g_hash_table_insert (builtin_items, "~power", power_menuitem);

431

g_hash_table_insert (builtin_items, "~session", session_menuitem);

432

g_hash_table_insert (builtin_items, "~language", language_menuitem);

433

g_hash_table_insert (builtin_items, "~a11y", a11y_menuitem);

434

g_hash_table_insert (builtin_items, "~layout", layout_menuitem);

435

436

g_hash_table_iter_init (&iter, builtin_items);

437

while (g_hash_table_iter_next (&iter, NULL, &iter_value))

438

gtk_container_remove (GTK_CONTAINER (menubar), iter_value);

489

names = (gchar**)DEFAULT_LAYOUT;

490

length = g_strv_length (names);

439

491

}

440

492

493

builtin_items = g_hash_table_new (g_str_hash, g_str_equal);

494

495

g_hash_table_insert (builtin_items, "~power", power_menuitem);

496

g_hash_table_insert (builtin_items, "~session", session_menuitem);

497

g_hash_table_insert (builtin_items, "~language", language_menuitem);

498

g_hash_table_insert (builtin_items, "~a11y", a11y_menuitem);

499

g_hash_table_insert (builtin_items, "~layout", layout_menuitem);

500

g_hash_table_insert (builtin_items, "~host", host_menuitem);

501

g_hash_table_insert (builtin_items, "~clock", clock_menuitem);

502

503

g_hash_table_iter_init (&iter, builtin_items);

504

while (g_hash_table_iter_next (&iter, NULL, &iter_value))

505

gtk_container_remove (GTK_CONTAINER (menubar), iter_value);

506

441

507

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

442

508

{

443

if (names[i][0] == '~' && g_hash_table_lookup_extended (builtin_items, names[i], NULL, &iter_value))

509

if (names[i][0] == '~')

444

510

{ /* Built-in indicators */

445

g_object_set_data (G_OBJECT (iter_value), "indicator-custom-index-data", GINT_TO_POINTER (i));

446

add_indicator_to_panel (iter_value, i);

447

g_hash_table_remove (builtin_items, (gconstpointer)names[i]);

511

GreeterPanelItemType item_type = PANEL_ITEM_INDICATOR;

512

if (g_hash_table_lookup_extended (builtin_items, names[i], NULL, &iter_value))

513

g_hash_table_remove (builtin_items, (gconstpointer)names[i]);

514

else if (g_strcmp0 (names[i], "~separator") == 0)

515

{

516

#if GTK_CHECK_VERSION (3, 0, 0)

517

GtkWidget *separator = gtk_separator_new (GTK_ORIENTATION_VERTICAL);

518

#else

519

GtkWidget *separator = gtk_vseparator_new ();

520

#endif

521

item_type = PANEL_ITEM_SEPARATOR;

522

iter_value = gtk_separator_menu_item_new ();

523

gtk_widget_show (separator);

524

gtk_container_add (iter_value, separator);

525

}

526

else if (g_strcmp0 (names[i], "~spacer") == 0)

527

{

528

item_type = PANEL_ITEM_SPACER;

529

iter_value = gtk_separator_menu_item_new ();

530

gtk_menu_item_set_label (iter_value, "");

531

#if GTK_CHECK_VERSION (3, 0, 0)

532

gtk_widget_set_hexpand (iter_value, TRUE);

533

#else

534

g_object_set_data(G_OBJECT(iter_value), GREETER_MENU_BAR_EXPAND_PROP, "1");

535

#endif

536

}

537

else if (names[i][1] == '~')

538

{

539

item_type = PANEL_ITEM_TEXT;

540

iter_value = gtk_separator_menu_item_new ();

541

gtk_menu_item_set_label (iter_value, &names[i][2]);

542

}

543

else

544

continue;

545

546

g_object_set_data (G_OBJECT (iter_value), PANEL_ITEM_DATA_INDEX, GINT_TO_POINTER (i));

547

panel_add_item (iter_value, i, item_type);

448

548

continue;

449

549

}

450

550

497

597

GList *entries, *lp;

498

598

499

599

/* used to store/fetch menu entries */

500

g_object_set_data_full (G_OBJECT (io), "indicator-custom-menuitems-data",

600

g_object_set_data_full (G_OBJECT (io), INDICATOR_DATA_MENUITEMS,

501

601

g_hash_table_new (g_direct_hash, g_direct_equal),

502

602

(GDestroyNotify) g_hash_table_destroy);

503

g_object_set_data (G_OBJECT (io), "indicator-custom-index-data", GINT_TO_POINTER (i));

603

g_object_set_data (G_OBJECT (io), PANEL_ITEM_DATA_INDEX, GINT_TO_POINTER (i));

504

604

505

605

g_signal_connect (G_OBJECT (io), INDICATOR_OBJECT_SIGNAL_ENTRY_ADDED,

506

G_CALLBACK (entry_added), menubar);

606

G_CALLBACK (indicator_entry_added_cb), menubar);

507

607

g_signal_connect (G_OBJECT (io), INDICATOR_OBJECT_SIGNAL_ENTRY_REMOVED,

508

G_CALLBACK (entry_removed), menubar);

608

G_CALLBACK (indicator_entry_removed_cb), menubar);

509

609

g_signal_connect (G_OBJECT (io), INDICATOR_OBJECT_SIGNAL_MENU_SHOW,

510

G_CALLBACK (menu_show), menubar);

610

G_CALLBACK (indicator_menu_show_cb), menubar);

511

611

512

612

entries = indicator_object_get_entries (io);

513

613

for (lp = entries; lp; lp = g_list_next (lp))

514

entry_added (io, lp->data, menubar);

614

indicator_entry_added_cb (io, lp->data, menubar);

515

615

g_list_free (entries);

516

616

}

517

617

else

522

622

g_free (path);

523

623

#endif

524

624

}

525

if (names)

625

if (names && names != (gchar**)DEFAULT_LAYOUT)

526

626

g_strfreev (names);

527

627

528

628

if (builtin_items)

1691

1791

gchar *font_name, **tokens;

1692

1792

guint length;

1693

1793

1694

/* Hide the clock since indicators are about to eat the screen. */

1695

gtk_widget_hide(GTK_WIDGET(clock_label));

1696

1697

1794

g_object_get (gtk_settings_get_default (), "gtk-font-name", &font_name, NULL);

1698

1795

tokens = g_strsplit (font_name, " ", -1);

1699

1796

length = g_strv_length (tokens);

1715

1812

else

1716

1813

{

1717

1814

g_object_set (gtk_settings_get_default (), "gtk-font-name", default_font_name, NULL);

1718

/* Show the clock as needed */

1719

gtk_widget_show_all(GTK_WIDGET(clock_label));

1720

1815

}

1721

1816

}

1722

1817

2166

2261

2167

2262

strftime(time_str, 50, clock_format, timeinfo);

2168

2263

markup = g_markup_printf_escaped("<b>%s</b>", time_str);

2169

if (g_strcmp0(markup, gtk_label_get_label(GTK_LABEL(clock_label))) != 0)

2170

gtk_label_set_markup( GTK_LABEL(clock_label), markup );

2264

if (g_strcmp0(markup, gtk_label_get_label (GTK_LABEL (clock_label))) != 0)

2265

gtk_label_set_markup (GTK_LABEL (clock_label), markup);

2171

2266

g_free(markup);

2172

2267

2173

2268

return TRUE;

2646

2741

gtk_style_context_add_class(GTK_STYLE_CONTEXT(gtk_widget_get_style_context(GTK_WIDGET(panel_window))), GTK_STYLE_CLASS_MENUBAR);

2647

2742

g_signal_connect (G_OBJECT (panel_window), "draw", G_CALLBACK (background_window_draw), NULL);

2648

2743

#endif

2649

gtk_label_set_text (GTK_LABEL (gtk_builder_get_object (builder, "hostname_label")), lightdm_get_hostname ());

2650

session_menu = GTK_MENU(gtk_builder_get_object (builder, "session_menu"));

2651

language_menu = GTK_MENU(gtk_builder_get_object (builder, "language_menu"));

2652

layout_menu = GTK_MENU(gtk_builder_get_object (builder, "layout_menu"));

2653

clock_label = GTK_WIDGET(gtk_builder_get_object (builder, "clock_label"));

2654

2744

menubar = GTK_WIDGET (gtk_builder_get_object (builder, "menubar"));

2655

2745

2656

2746

/* Login window */

2704

2794

2705

2795

/* Indicators */

2706

2796

session_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "session_menuitem"));

2797

session_menu = GTK_MENU(gtk_builder_get_object (builder, "session_menu"));

2707

2798

language_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "language_menuitem"));

2799

language_menu = GTK_MENU(gtk_builder_get_object (builder, "language_menu"));

2708

2800

a11y_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "a11y_menuitem"));

2709

2801

power_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "power_menuitem"));

2710

2802

layout_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "layout_menuitem"));

2803

layout_menu = GTK_MENU(gtk_builder_get_object (builder, "layout_menu"));

2711

2804

keyboard_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "keyboard_menuitem"));

2805

clock_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "clock_menuitem"));

2806

host_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "host_menuitem"));

2712

2807

2713

2808

gtk_accel_map_add_entry ("<Login>/a11y/font", GDK_KEY_F1, 0);

2714

2809

gtk_accel_map_add_entry ("<Login>/a11y/contrast", GDK_KEY_F2, 0);

2738

2833

g_free (value);

2739

2834

}

2740

2835

2741

/* Clock */

2742

gtk_widget_set_no_show_all(GTK_WIDGET(clock_label),

2743

!g_key_file_get_boolean (config, "greeter", "show-clock", NULL));

2744

gtk_widget_show_all(GTK_WIDGET(clock_label));

2745

clock_format = g_key_file_get_value (config, "greeter", "clock-format", NULL);

2746

if (!clock_format)

2747

clock_format = "%a, %H:%M";

2748

clock_timeout_thread();

2749

2750

2836

/* Session menu */

2751

2837

if (gtk_widget_get_visible (session_menuitem))

2752

2838

{

2814

2900

}

2815

2901

set_language (NULL);

2816

2902

}

2817

2903

2818

2904

/* a11y menu */

2819

2905

if (gtk_widget_get_visible (a11y_menuitem))

2820

2906

{

2882

2968

update_layouts_menu_state ();

2883

2969

}

2884

2970

2971

/* Host label */

2972

if (gtk_widget_get_visible (host_menuitem))

2973

gtk_menu_item_set_label (GTK_MENU_ITEM (host_menuitem), lightdm_get_hostname ());

2974

2975

/* Clock label */

2976

if (gtk_widget_get_visible (clock_menuitem))

2977

{

2978

gtk_menu_item_set_label (GTK_MENU_ITEM (clock_menuitem), "");

2979

clock_label = gtk_bin_get_child (GTK_BIN (clock_menuitem));

2980

clock_format = g_key_file_get_value (config, "greeter", "clock-format", NULL);

2981

if (!clock_format)

2982

clock_format = "%a, %H:%M";

2983

clock_timeout_thread ();

2984

gdk_threads_add_timeout (1000, (GSourceFunc) clock_timeout_thread, NULL);

2985

}

2986

2885

2987

#if GTK_CHECK_VERSION (3, 0, 0)

2886

2988

/* A bit of CSS */

2887

2989

css_provider = gtk_css_provider_new ();

3011

3113

}

3012

3114

gtk_widget_set_sensitive (keyboard_menuitem, a11y_keyboard_command != NULL);

3013

3115

gtk_widget_set_visible (keyboard_menuitem, a11y_keyboard_command != NULL);

3014

gdk_threads_add_timeout (1000, (GSourceFunc) clock_timeout_thread, NULL);

3015

3116

3016

3117

/* focus fix (source: unity-greeter) */

3017

3118

GdkWindow* root_window = gdk_get_default_root_window ();