Grcov report - ipuz-crossword.c

1

/* ipuz-crossword.c

2

3

 * Copyright 2022 Jonathan Blandford <jrb@gnome.org>

4

5

 * This library is free software; you can redistribute it and/or

6

 * modify it under the terms of the GNU Lesser General Public

7

 * License as published by the Free Software Foundation; either

8

 * version 2.1 of the License, or (at your option) any later version.

9

10

 * This library is distributed in the hope that it will be useful,

11

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

12

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

13

 * Lesser General Public License for more details.

14

15

 * You should have received a copy of the GNU Lesser General Public

16

 * License along with this library; if not, write to the Free Software

17

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

18

19

 * SPDX-License-Identifier: (LGPL-2.1-or-later OR MIT)

20

*/

21

22

23

#include "libipuz-config.h"

24

#include "libipuz.h"

25

#include "libipuz-enums.h"

26

#include "ipuz-clue-sets.h"

27

#include "ipuz-magic.h"

28

#include "ipuz-puzzle-info-private.h"

29

#include "rust/ipuz-rust.h"

30

31

#include <libipuz/ipuz-puzzle.h>

32

#include <libipuz/ipuz-crossword.h>

33

#include <libipuz/ipuz-board.h>

34

#include <glib/gi18n-lib.h>

35

36

37

enum

38

39

  PROP_0,

40

  PROP_WIDTH,

41

  PROP_HEIGHT,

42

  PROP_SHOWENUMERATIONS,

43

  PROP_CLUE_PLACEMENT,

44

  PROP_BOARD,

45

  PROP_GUESSES,

46

  N_PROPS

47

};

48

static GParamSpec *obj_props[N_PROPS] = { NULL, };

49

50

51

typedef struct _IPuzCrosswordPrivate

52

53

  gint width;

54

  gint height;

55

  gboolean showenumerations;

56

  IPuzClueSets *clue_sets;

57

58

  IPuzBoard *board;

59

  IPuzGuesses *guesses;

60

61

  gboolean uses_extensions;

62

  gboolean has_solution;

63

  gboolean has_saved;

64

  IPuzCluePlacement clue_placement;

65

/*

66

"zones": [ GroupSpec, ... ]

67

		Arbitrarily-shaped entries overlaid on the grid

68

"answer": "entry"

69

		The final answer to the puzzle

70

"answers": [ "entry", ... ]

71

		List of final answers to the puzzle

72

"enumeration": Enumeration

73

		Enumeration of the final answer to the puzzle

74

"enumerations": [ Enumeration, ... ]

75

		List of enumerations for final answers to the puzzle

76

"misses": { "entry": "hint", ... }

77

		List of hints to be given for misses

78

*/

79

} IPuzCrosswordPrivate;

80

81

82

static void                ipuz_crossword_init                      (IPuzCrossword      *self);

83

static void                ipuz_crossword_class_init                (IPuzCrosswordClass *klass);

84

static void                ipuz_crossword_finalize                  (GObject            *object);

85

static void                ipuz_crossword_set_property              (GObject            *object,

86

                                                                     guint               prop_id,

87

                                                                     const GValue       *value,

88

                                                                     GParamSpec         *pspec);

89

static void                ipuz_crossword_get_property              (GObject            *object,

90

                                                                     guint               prop_id,

91

                                                                     GValue             *value,

92

                                                                     GParamSpec         *pspec);

93

static void                ipuz_crossword_set_property              (GObject            *object,

94

                                                                     guint               prop_id,

95

                                                                     const GValue       *value,

96

                                                                     GParamSpec         *pspec);

97

static void                ipuz_crossword_get_property              (GObject            *object,

98

                                                                     guint               prop_id,

99

                                                                     GValue             *value,

100

                                                                     GParamSpec         *pspec);

101

static void                ipuz_crossword_load_node                 (IPuzPuzzle         *puzzle,

102

                                                                     const char         *member_name,

103

                                                                     JsonNode           *node);

104

static void                ipuz_crossword_post_load_node            (IPuzPuzzle         *puzzle,

105

                                                                     const char         *member_name,

106

                                                                     JsonNode           *node);

107

static void                ipuz_crossword_fixup                     (IPuzPuzzle         *puzzle);

108

static void                ipuz_crossword_build                     (IPuzPuzzle         *puzzle,

109

                                                                     JsonBuilder        *builder);

110

static IPuzPuzzleFlags     ipuz_crossword_get_flags                 (IPuzPuzzle         *puzzle);

111

static void                ipuz_crossword_calculate_info            (IPuzPuzzle         *puzzle,

112

                                                                     IPuzPuzzleInfo      *info);

113

static void                ipuz_crossword_clone                     (IPuzPuzzle         *src,

114

                                                                     IPuzPuzzle         *dest);

115

static const gchar *const *ipuz_crossword_get_kind_str              (IPuzPuzzle         *puzzle);

116

static void                ipuz_crossword_set_style                 (IPuzPuzzle         *puzzle,

117

                                                                     const gchar        *style_name,

118

                                                                     IPuzStyle          *style);

119

static gboolean            ipuz_crossword_equal                     (IPuzPuzzle         *puzzle_a,

120

                                                                     IPuzPuzzle         *puzzle_b);

121

static void                ipuz_crossword_real_fix_symmetry         (IPuzCrossword      *self,

122

                                                                     IPuzSymmetry        symmetry,

123

                                                                     GArray             *coords);

124

static void                ipuz_crossword_real_fix_numbering        (IPuzCrossword      *self);

125

static void                ipuz_crossword_real_fix_clues            (IPuzCrossword      *self);

126

static void                ipuz_crossword_real_fix_enumerations     (IPuzCrossword      *self);

127

static void                ipuz_crossword_real_fix_styles           (IPuzCrossword      *self);

128

static void                ipuz_crossword_real_fix_all              (IPuzCrossword      *self,

129

                                                                     const gchar        *first_attribute_name,

130

                                                                     va_list             var_args);

131

static gboolean            ipuz_crossword_real_clue_continues_up    (IPuzCrossword      *self,

132

                                                                     IPuzCellCoord       coord);

133

static gboolean            ipuz_crossword_real_clue_continues_down  (IPuzCrossword      *self,

134

                                                                     IPuzCellCoord       coord);

135

static gboolean            ipuz_crossword_real_clue_continues_left  (IPuzCrossword      *self,

136

                                                                     IPuzCellCoord       coord);

137

static gboolean            ipuz_crossword_real_clue_continues_right (IPuzCrossword      *self,

138

                                                                     IPuzCellCoord       coord);

139

static void                ipuz_crossword_real_mirror_cell          (IPuzCrossword      *self,

140

                                                                     IPuzCellCoord       src_coord,

141

                                                                     IPuzCellCoord       dest_coord,

142

                                                                     IPuzSymmetry        symmetry,

143

                                                                     IPuzSymmetryOffset  symmetry_offset);

144

static gboolean            ipuz_crossword_real_check_mirror         (IPuzCrossword      *self,

145

                                                                     IPuzCellCoord       src_coord,

146

                                                                     IPuzCellCoord       target_coord,

147

                                                                     IPuzSymmetry        symmetry,

148

                                                                     IPuzSymmetryOffset  symmetry_offset);

149

static gboolean            ipuz_crossword_real_set_size             (IPuzCrossword      *self,

150

                                                                     gint                width,

151

                                                                     gint                height);

152

static IPuzClue           *calculate_clue                           (IPuzCrossword      *self,

153

                                                                     IPuzClueDirection   direction,

154

                                                                     IPuzCellCoord       coord,

155

                                                                     gint                number);

156

157

158

6

G_DEFINE_TYPE_WITH_CODE (IPuzCrossword, ipuz_crossword, IPUZ_TYPE_PUZZLE,

159

                         G_ADD_PRIVATE (IPuzCrossword));

160

161

162

static void

163

43

ipuz_crossword_init_clues (IPuzCrossword *self)

164

165

  IPuzCrosswordPrivate *priv;

166

167

43

  priv = ipuz_crossword_get_instance_private (IPUZ_CROSSWORD (self));

168

169

43

  g_clear_pointer (&priv->clue_sets, ipuz_clue_sets_unref);

170

43

  priv->clue_sets = ipuz_clue_sets_new ();

171

43

172

173

static void

174

39

ipuz_crossword_init (IPuzCrossword *self)

175

176

  IPuzCrosswordPrivate *priv;

177

178

39

  priv = ipuz_crossword_get_instance_private (self);

179

180

39

  priv->showenumerations = FALSE;

181

39

  priv->width = 0;

182

39

  priv->height = 0;

183

39

  priv->board = ipuz_board_new ();

184

39

  ipuz_crossword_init_clues (self);

185

186

39

  ipuz_noop ();

187

39

188

189

static void

190

6

ipuz_crossword_class_init (IPuzCrosswordClass *klass)

191

192

6

  GObjectClass *object_class = G_OBJECT_CLASS(klass);

193

6

  IPuzPuzzleClass *puzzle_class = IPUZ_PUZZLE_CLASS (klass);

194

6

  IPuzCrosswordClass *crossword_class = IPUZ_CROSSWORD_CLASS (klass);

195

196

6

  object_class->finalize = ipuz_crossword_finalize;

197

6

  object_class->set_property = ipuz_crossword_set_property;

198

6

  object_class->get_property = ipuz_crossword_get_property;

199

6

  puzzle_class->load_node = ipuz_crossword_load_node;

200

6

  puzzle_class->post_load_node = ipuz_crossword_post_load_node;

201

6

  puzzle_class->fixup = ipuz_crossword_fixup;

202

6

  puzzle_class->build = ipuz_crossword_build;

203

6

  puzzle_class->get_flags = ipuz_crossword_get_flags;

204

6

  puzzle_class->calculate_info = ipuz_crossword_calculate_info;

205

6

  puzzle_class->clone = ipuz_crossword_clone;

206

6

  puzzle_class->get_kind_str = ipuz_crossword_get_kind_str;

207

6

  puzzle_class->set_style = ipuz_crossword_set_style;

208

6

  puzzle_class->equal = ipuz_crossword_equal;

209

6

  crossword_class->fix_symmetry = ipuz_crossword_real_fix_symmetry;

210

6

  crossword_class->fix_numbering = ipuz_crossword_real_fix_numbering;

211

6

  crossword_class->fix_clues = ipuz_crossword_real_fix_clues;

212

6

  crossword_class->fix_enumerations = ipuz_crossword_real_fix_enumerations;

213

6

  crossword_class->fix_styles = ipuz_crossword_real_fix_styles;

214

6

  crossword_class->fix_all = ipuz_crossword_real_fix_all;

215

6

  crossword_class->clue_continues_up = ipuz_crossword_real_clue_continues_up;

216

6

  crossword_class->clue_continues_down = ipuz_crossword_real_clue_continues_down;

217

6

  crossword_class->clue_continues_left = ipuz_crossword_real_clue_continues_left;

218

6

  crossword_class->clue_continues_right = ipuz_crossword_real_clue_continues_right;

219

6

  crossword_class->mirror_cell = ipuz_crossword_real_mirror_cell;

220

6

  crossword_class->check_mirror = ipuz_crossword_real_check_mirror;

221

222

6

  obj_props[PROP_WIDTH] = g_param_spec_int ("width",

223

                                            _("width"),

224

                                            _("Width of the puzzle grid"),

225

                                            0, 65536, 0,

226

                                            G_PARAM_READWRITE);

227

6

  obj_props[PROP_HEIGHT] = g_param_spec_int ("height",

228

                                             _("height"),

229

                                             _("height of the puzzle grid"),

230

                                             0, 65536, 0,

231

                                             G_PARAM_READWRITE);

232

6

  obj_props[PROP_SHOWENUMERATIONS] = g_param_spec_boolean ("showenumerations",

233

                                                           _("Show Enumerations"),

234

                                                           _("Show enumerations with clues"),

235

                                                           FALSE,

236

                                                           G_PARAM_READWRITE);

237

6

  obj_props[PROP_CLUE_PLACEMENT] = g_param_spec_enum ("clue-placement",

238

                                                      _("Clue Placement"),

239

                                                      _("Where to put clues"),

240

                                                      I_TYPE_PUZ_CLUE_PLACEMENT,

241

                                                      IPUZ_CLUE_PLACEMENT_NULL,

242

                                                      G_PARAM_READWRITE);

243

6

  obj_props[PROP_BOARD] = g_param_spec_object ("board",

244

                                               _("Board"),

245

                                               _("The crossword board"),

246

                                               IPUZ_TYPE_BOARD,

247

                                               G_PARAM_READABLE);

248

6

  obj_props[PROP_GUESSES] = g_param_spec_boxed ("guesses",

249

                                                _("Guesses"),

250

                                                _("The guesses associated with this crossword"),

251

                                                IPUZ_TYPE_GUESSES,

252

                                                G_PARAM_READWRITE);

253

6

  g_object_class_install_properties (object_class, N_PROPS, obj_props);

254

6

255

256

/* free all memory */

257

static void

258

39

ipuz_crossword_finalize (GObject *object)

259

260

  IPuzCrosswordPrivate *priv;

261

262

39

  g_return_if_fail (object != NULL);

263

264

39

  priv = ipuz_crossword_get_instance_private (IPUZ_CROSSWORD (object));

265

266

39

  g_clear_pointer (&priv->clue_sets, ipuz_clue_sets_unref);

267

268

39

  g_object_unref (G_OBJECT (priv->board));

269

39

  ipuz_guesses_unref (priv->guesses);

270

271

39

  G_OBJECT_CLASS (ipuz_crossword_parent_class)->finalize (object);

272

273

274

static void

275

26

ipuz_crossword_set_property (GObject      *object,

276

                             guint         prop_id,

277

                             const GValue *value,

278

                             GParamSpec   *pspec)

279

280

  IPuzCrosswordPrivate *priv;

281

282

26

  priv = ipuz_crossword_get_instance_private (IPUZ_CROSSWORD (object));

283

284

26

  switch (prop_id)

285

286

    case PROP_WIDTH:

287

      ipuz_crossword_real_set_size (IPUZ_CROSSWORD (object),

288

                                    g_value_get_int (value),

289

                                    priv->height);

290

      break;

291

    case PROP_HEIGHT:

292

      ipuz_crossword_real_set_size (IPUZ_CROSSWORD (object),

293

                                    priv->width,

294

                                    g_value_get_int (value));

295

      break;

296

26

    case PROP_SHOWENUMERATIONS:

297

26

      priv->showenumerations = g_value_get_boolean (value);

298

26

      break;

299

    case PROP_CLUE_PLACEMENT:

300

      priv->clue_placement = g_value_get_enum (value);

301

      break;

302

    case PROP_GUESSES:

303

      ipuz_crossword_set_guesses (IPUZ_CROSSWORD (object), (IPuzGuesses *)g_value_get_boxed (value));

304

      break;

305

    default:

306

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

307

      break;

308

309

26

310

311

static void

312

23

ipuz_crossword_get_property (GObject    *object,

313

                             guint       prop_id,

314

                             GValue     *value,

315

                             GParamSpec *pspec)

316

317

  IPuzCrosswordPrivate *priv;

318

319

23

  priv = ipuz_crossword_get_instance_private (IPUZ_CROSSWORD (object));

320

321

23

  switch (prop_id)

322

323

4

    case PROP_WIDTH:

324

4

      g_value_set_int (value, priv->width);

325

4

      break;

326

4

    case PROP_HEIGHT:

327

4

      g_value_set_int (value, priv->height);

328

4

      break;

329

7

    case PROP_SHOWENUMERATIONS:

330

7

      g_value_set_boolean (value, priv->showenumerations);

331

7

      break;

332

4

    case PROP_CLUE_PLACEMENT:

333

4

      g_value_set_enum (value, priv->clue_placement);

334

4

      break;

335

4

    case PROP_BOARD:

336

4

      g_value_set_object (value, priv->board);

337

4

      break;

338

    case PROP_GUESSES:

339

      g_value_set_boxed (value, priv->guesses);

340

      break;

341

    default:

342

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

343

      break;

344

345

23

346

347

static void

348

32

load_dimensions (IPuzCrossword *self,

349

                 JsonNode      *node)

350

351

32

  gint width = -1;

352

32

  gint height = -1;

353

354

32

  if (!JSON_NODE_HOLDS_OBJECT (node))

355

    return;

356

357

64

  g_autoptr(JsonReader) reader = json_reader_new (node);

358

32

  if (json_reader_read_member (reader, "width"))

359

32

    width = json_reader_get_int_value (reader);

360

32

  json_reader_end_member (reader);

361

362

32

  if (json_reader_read_member (reader, "height"))

363

32

    height = json_reader_get_int_value (reader);

364

32

  json_reader_end_member (reader);

365

366

32

  if (width > 0 && height > 0)

367

32

    ipuz_crossword_real_set_size (self, width, height);

368

369

370

static void

371

738

load_clues_foreach (JsonArray *array,

372

                    guint      index,

373

                    JsonNode  *element_node,

374

                    gpointer   user_data)

375

376

  IPuzClue *clue;

377

378

738

  clue = ipuz_clue_new_from_json (element_node);

379

738

  GArray *clues = (GArray *) user_data;

380

738

  g_array_append_val (clues, clue);

381

738

382

383

static void

384

30

load_clues (IPuzCrossword *self,

385

            JsonNode      *node)

386

387

  IPuzCrosswordPrivate *priv;

388

30

  JsonObjectIter iter = {0, };

389

30

  const gchar *member_name = NULL;

390

  JsonNode *member_node;

391

392

30

  if (!JSON_NODE_HOLDS_OBJECT (node))

393

    return;

394

395

30

  priv = ipuz_crossword_get_instance_private (IPUZ_CROSSWORD (self));

396

397

30

  json_object_iter_init (&iter, json_node_get_object (node));

398

85

  while (json_object_iter_next (&iter, &member_name, &member_node))

399

400

      IPuzClueDirection direction;

401

      GArray *clues;

402

      gchar **strv;

403

404

      /* conditions for parsing clues. It has to be a direction we know, and has

405

       * to be an array. We should look into better error handling here.

406

       * FIXME(error-handling): See issue #26

407

*/

408

55

      if (! JSON_NODE_HOLDS_ARRAY (member_node))

409

        continue;

410

411

55

      strv = g_strsplit_set (member_name, ":", 2);

412

55

      if (strv == NULL || strv[0] == NULL)

413

        continue;

414

415

55

      direction = ipuz_clue_sets_add_set (priv->clue_sets,

416

                                          ipuz_clue_direction_from_string (strv[0]),

417

55

                                          strv[1]);

418

55

      clues = ipuz_clue_sets_get_clues (priv->clue_sets, direction);

419

55

      g_strfreev (strv);

420

421

55

      if (direction == IPUZ_CLUE_DIRECTION_NONE)

422

        continue;

423

424

      /* Load the clues */

425

55

      json_array_foreach_element (json_node_get_array (member_node), load_clues_foreach, clues);

426

427

      /* The json section of each clue doesn't contain the direction. Go back and set it

428

       * as a second pass.

429

*/

430

793

      for (guint i = 0; i < clues->len; i++)

431

738

        ipuz_clue_set_direction (g_array_index (clues, IPuzClue *, i), direction);

432

433

434

435

static void

436

load_clue_placement (IPuzCrossword *self,

437

                     JsonNode      *node)

438

439

  IPuzCrosswordPrivate *priv;

440

  const gchar *clueplacement = NULL;

441

442

  priv = ipuz_crossword_get_instance_private (IPUZ_CROSSWORD (self));

443

444

  clueplacement = json_node_get_string (node);

445

  if (clueplacement == NULL)

446

    priv->clue_placement = IPUZ_CLUE_PLACEMENT_NULL;

447

  else if (g_strcmp0 (clueplacement, "before") == 0)

448

    priv->clue_placement = IPUZ_CLUE_PLACEMENT_BEFORE;

449

  else if (g_strcmp0 (clueplacement, "after") == 0)

450

    priv->clue_placement = IPUZ_CLUE_PLACEMENT_AFTER;

451

  else if (g_strcmp0 (clueplacement, "blocks") == 0)

452

    priv->clue_placement = IPUZ_CLUE_PLACEMENT_BLOCKS;

453

  else

454

    priv->clue_placement = IPUZ_CLUE_PLACEMENT_NULL;

455

456

457

static void

458

358

ipuz_crossword_load_node (IPuzPuzzle *puzzle,

459

                          const char *member_name,

460

                          JsonNode   *node)

461

462

463

358

  g_return_if_fail (member_name != NULL);

464

358

  g_return_if_fail (node != NULL);

465

466

358

  if (strcmp (member_name, "dimensions") == 0)

467

468

32

      load_dimensions (IPUZ_CROSSWORD (puzzle), node);

469

32

      return;

470

471

326

  if (strcmp (member_name, "clues") == 0)

472

473

30

      load_clues (IPUZ_CROSSWORD (puzzle), node);

474

30

      return;

475

476

296

  if (strcmp (member_name, "clueplacement") == 0)

477

478

      load_clue_placement (IPUZ_CROSSWORD (puzzle), node);

479

      return;

480

481

482

296

  IPUZ_PUZZLE_CLASS (ipuz_crossword_parent_class)->load_node (puzzle, member_name, node);

483

484

485

486

static void

487

358

ipuz_crossword_post_load_node (IPuzPuzzle *puzzle,

488

                               const char *member_name,

489

                               JsonNode   *node)

490

491

  IPuzCrosswordPrivate *priv;

492

493

358

  g_return_if_fail (member_name != NULL);

494

358

  g_return_if_fail (node != NULL);

495

496

358

  priv = ipuz_crossword_get_instance_private (IPUZ_CROSSWORD (puzzle));

497

498

358

  if (strcmp (member_name, "puzzle") == 0)

499

500

32

      g_autofree gchar *block, *empty;

501

32

      g_object_get (G_OBJECT (puzzle),

502

                    "block", &block,

503

                    "empty", &empty,

504

                    NULL);

505

32

      ipuz_board_parse_puzzle (priv->board, node, block, empty);

506

32

      return;

507

508

326

  if (strcmp (member_name, "solution") == 0)

509

510

30

      g_autofree gchar *block, *charset_str;

511

30

      g_object_get (G_OBJECT (puzzle),

512

                    "block", &block,

513

                    "charset-str", &charset_str,

514

                    NULL);

515

30

      ipuz_board_parse_solution (priv->board, node, block, charset_str);

516

30

      priv->has_solution = TRUE;

517

30

      return;

518

519

296

  if (strcmp (member_name, "saved") == 0)

520

521

      /* FIXME(saved): Load the saved guesses from disk */

522

523

524

525

/* This will try its best to determine the cells of the clues when

526

 * there aren't any provided by then puzzle. There are times we can't

527

 * detect anything, and clues won't have cells associated with

528

 * them. That happens with some puzzles (such as alphabetic) */

529

static void

530

191

autodetect_cells_for_clue (IPuzClue     *clue,

531

                           IPuzClueSets *clue_sets,

532

                           IPuzBoard    *board)

533

534

  IPuzCell *cell;

535

  IPuzCellCoord coord;

536

  const GArray *cells;

537

  IPuzClueDirection direction;

538

539

191

  cells = ipuz_clue_get_cells (clue);

540

191

  g_assert (cells->len == 0);

541

542

191

  cell = ipuz_board_get_cell_by_clue (board, clue, &coord);

543

544

191

  if (cell == NULL)

545

    /* We have a clue with a label/number that's not in the

546

     * grid.

547

*/

548

    return;

549

550

191

  direction = ipuz_clue_sets_get_original_direction (clue_sets,

551

                                                     ipuz_clue_get_direction (clue));

552

553

191

  if (! IPUZ_CLUE_DIRECTION_HEADING (direction))

554

    return;

555

556

1438

  while (cell != NULL && ipuz_cell_get_cell_type (cell) == IPUZ_CELL_NORMAL)

557

558

1247

      ipuz_clue_append_cell (clue, coord);

559

1247

      ipuz_cell_set_clue (cell, clue);

560

561

1247

      switch (direction)

562

563

646

        case IPUZ_CLUE_DIRECTION_ACROSS:

564

646

          coord.column ++;

565

646

          break;

566

601

        case IPUZ_CLUE_DIRECTION_DOWN:

567

601

          coord.row ++;

568

601

          break;

569

        case IPUZ_CLUE_DIRECTION_DIAGONAL:

570

          coord.column ++;

571

          coord.row ++;

572

          break;

573

        case IPUZ_CLUE_DIRECTION_DIAGONAL_UP:

574

          coord.column ++;

575

          coord.row --;

576

          break;

577

        case IPUZ_CLUE_DIRECTION_DIAGONAL_DOWN_LEFT:

578

          coord.column --;

579

          coord.row ++;

580

          break;

581

        case IPUZ_CLUE_DIRECTION_DIAGONAL_UP_LEFT:

582

          coord.column --;

583

          coord.row --;

584

          break;

585

        default:

586

          /* We don't know which way to go from here. Just include the

587

           * first cell */

588

          break;

589

590

1247

      cell = ipuz_board_get_cell (board, coord);

591

592

593

594

/* This function makes sure that each clue has its "cells" set correctly.

595

 * Either its explicitly set by the puzzle, or implicitly done by the board

596

 * itself. Either way, we need to link back from the Cell to the Clue.

597

598

 * Question: Should we move this to IPuzClue? We should also split it in half.

599

 * */

600

static void

601

865

crossword_ensure_cells (IPuzClue     *clue,

602

                        IPuzClueSets *clue_sets,

603

                        IPuzBoard    *board)

604

605

  const GArray *cells;

606

  IPuzCellCoord coord;

607

  IPuzCell *cell;

608

609

865

  cells = ipuz_clue_get_cells (clue);

610

611

  /* Try to autodetect the cells */

612

865

  if (cells->len == 0)

613

191

    autodetect_cells_for_clue (clue, clue_sets, board);

614

615

  /* the clue already has cells loaded. */

616

865

  if (cells->len > 0)

617

618

6076

      for (guint i = 0; i < cells->len; i ++)

619

620

5211

          coord = g_array_index (clue->cells, IPuzCellCoord, i);

621

5211

          cell = ipuz_board_get_cell (board, coord);

622

5211

          ipuz_cell_set_clue (cell, clue);

623

624

865

      return;

625

626

627

628

/* Makes sure cells have their style associated with them */

629

static void

630

32

ipuz_crossword_fixup_cells (IPuzCrossword *self)

631

632

  IPuzCrosswordPrivate *priv;

633

32

  g_autoptr(GHashTable) styles = NULL;

634

  guint row, col;

635

636

32

  priv = ipuz_crossword_get_instance_private (IPUZ_CROSSWORD (self));

637

638

32

  g_object_get (G_OBJECT (self),

639

                "styles", &styles,

640

                NULL);

641

642

32

  if (styles == NULL)

643

28

    return;

644

645

56

  for (row = 0; row < (guint) priv->height; row++)

646

647

740

      for (col = 0; col < (guint) priv->width; col++)

648

649

          IPuzCell *cell;

650

688

          IPuzCellCoord coord = { .row = row, .column = col };

651

652

688

          cell = ipuz_crossword_get_cell (self, coord);

653

688

          if (cell->style_name)

654

655

              IPuzStyle *style;

656

657

              /* FIXME: we shouldn't touch this directly. Instad, we

658

               * should add a get_style_name() function */

659

243

              style = g_hash_table_lookup (styles, cell->style_name);

660

243

              ipuz_cell_set_style (cell, style, cell->style_name);

661

662

663

688

          if (IPUZ_CELL_IS_BLOCK (cell) && cell->style != NULL)

664

71

            priv->uses_extensions = TRUE;

665

666

688

          if (cell->saved_guess != NULL)

667

            priv->has_saved = TRUE;

668

669

670

671

672

static  void

673

63

ipuz_crossword_fixup_clues_helper (IPuzClueSets            *clue_sets,

674

                                   IPuzClueDirection        direction,

675

                                   gpointer                 user_data)

676

677

  IPuzCrosswordPrivate *priv;

678

  GArray *clues;

679

680

63

  priv = ipuz_crossword_get_instance_private (IPUZ_CROSSWORD (user_data));

681

63

  clues = ipuz_clue_sets_get_clues (clue_sets, direction);

682

683

928

  for (guint i = 0; i < clues->len; i++)

684

685

      IPuzClue *clue;

686

687

865

      clue = g_array_index (clues, IPuzClue *, i);

688

865

      crossword_ensure_cells (clue, clue_sets, priv->board);

689

865

      if (priv->showenumerations)

690

441

        ipuz_clue_ensure_enumeration (clue);

691

692

63

693

694

/* Make sure every clue has its "cells" set.

695

 * Update the enumeration if necessary

696

*/

697

static void

698

36

ipuz_crossword_fixup_clues (IPuzCrossword *self)

699

700

  IPuzCrosswordPrivate *priv;

701

702

36

  priv = ipuz_crossword_get_instance_private (IPUZ_CROSSWORD (self));

703

704

36

  ipuz_clue_sets_foreach (priv->clue_sets,

705

                          ipuz_crossword_fixup_clues_helper,

706

                          self);

707

36

708

709

static void

710

32

ipuz_crossword_fixup (IPuzPuzzle *puzzle)

711

712

  IPuzCrossword *self;

713

714

32

  self = IPUZ_CROSSWORD (puzzle);

715

716

32

  ipuz_crossword_fixup_clues (self);

717

32

  ipuz_crossword_fixup_cells (self);

718

719

32

  IPUZ_PUZZLE_CLASS (ipuz_crossword_parent_class)->fixup (puzzle);

720

32

721

722

static void

723

2

build_dimensions (IPuzCrossword *self,

724

                  JsonBuilder   *builder)

725

726

  IPuzCrosswordPrivate *priv;

727

728

2

  priv = ipuz_crossword_get_instance_private (self);

729

730

2

  json_builder_set_member_name (builder, "dimensions");

731

2

  json_builder_begin_object (builder);

732

2

  json_builder_set_member_name (builder, "width");

733

2

  json_builder_add_int_value (builder, priv->width);

734

2

  json_builder_set_member_name (builder, "height");

735

2

  json_builder_add_int_value (builder, priv->height);

736

2

  json_builder_end_object (builder);

737

2

738

739

static void

740

3

build_clues (IPuzCrossword *self,

741

             JsonBuilder   *builder,

742

             const gchar   *member,

743

             GArray        *clues)

744

745

  guint i;

746

747

3

  if (clues->len == 0)

748

    return;

749

3

  json_builder_set_member_name (builder, member);

750

3

  json_builder_begin_array (builder);

751

60

  for (i = 0; i < clues->len; i++)

752

753

      IPuzClue *clue;

754

57

      clue = g_array_index (clues, IPuzClue *, i);

755

57

      ipuz_clue_build (clue, builder);

756

757

3

  json_builder_end_array (builder);

758

759

760

typedef struct

761

762

  IPuzPuzzle *puzzle;

763

  JsonBuilder *builder;

764

} BuildHelperTuple;

765

766

static void

767

3

build_helper (IPuzClueSets      *clue_sets,

768

              IPuzClueDirection  direction,

769

              gpointer           user_data)

770

771

3

  BuildHelperTuple *tuple = user_data;

772

  IPuzClueDirection original_direction;

773

  const gchar *label;

774

  GArray *clues;

775

776

3

  original_direction = ipuz_clue_sets_get_original_direction (clue_sets, direction);

777

3

  label = ipuz_clue_sets_get_label (clue_sets, direction);

778

3

  clues = ipuz_clue_sets_get_clues (clue_sets, direction);

779

780

3

  if (label)

781

782

3

      g_autofree gchar *member = NULL;

783

3

      member = g_strconcat (ipuz_clue_direction_to_string (original_direction),

784

                            ":", label, NULL);

785

3

      build_clues (IPUZ_CROSSWORD (tuple->puzzle), tuple->builder,

786

                   member, clues);

787

788

  else

789

790

      build_clues (IPUZ_CROSSWORD (tuple->puzzle), tuple->builder,

791

                   ipuz_clue_direction_to_string (original_direction),

792

                   clues);

793

794

3

795

796

797

static void

798

2

ipuz_crossword_build (IPuzPuzzle  *puzzle,

799

                      JsonBuilder *builder)

800

801

  IPuzCrosswordPrivate *priv;

802

2

  g_autofree gchar *block = NULL;

803

2

  g_autofree gchar *empty = NULL;

804

805

2

  priv = ipuz_crossword_get_instance_private (IPUZ_CROSSWORD (puzzle));

806

807

2

  g_object_get (G_OBJECT (puzzle),

808

                "block", &block,

809

                "empty", &empty,

810

                NULL);

811

812

  /* We chain to the parent class first to get meta-information. Not

813

   * every parsing section can handle this coming at the end. */

814

2

  IPUZ_PUZZLE_CLASS (ipuz_crossword_parent_class)->build (puzzle, builder);

815

816

2

  build_dimensions (IPUZ_CROSSWORD (puzzle), builder);

817

2

  json_builder_set_member_name (builder, "showenumerations");

818

2

  json_builder_add_boolean_value (builder, priv->showenumerations);

819

2

  if (priv->clue_placement != IPUZ_CLUE_PLACEMENT_NULL)

820

821

      const gchar *clueplacement = NULL;

822

823

      switch (priv->clue_placement)

824

825

        case IPUZ_CLUE_PLACEMENT_BEFORE:

826

          clueplacement = "before";

827

          break;

828

        case IPUZ_CLUE_PLACEMENT_AFTER:

829

          clueplacement = "after";

830

          break;

831

        case IPUZ_CLUE_PLACEMENT_BLOCKS:

832

          clueplacement = "blocks";

833

          break;

834

        default:

835

          break;

836

837

      if (clueplacement)

838

839

          json_builder_set_member_name (builder, "clueplacement");

840

          json_builder_add_string_value (builder, clueplacement);

841

842

843

844

2

  ipuz_board_build_puzzle (priv->board, builder, block, empty);

845

2

  ipuz_board_build_solution (priv->board, builder, block);

846

847

848

2

  if (ipuz_clue_sets_get_n_clue_sets (priv->clue_sets) > 0)

849

850

      BuildHelperTuple tuple;

851

2

      tuple.builder = builder;

852

2

      tuple.puzzle = puzzle;

853

854

2

      json_builder_set_member_name (builder, "clues");

855

2

      json_builder_begin_object (builder);

856

857

2

      ipuz_clue_sets_foreach (priv->clue_sets, build_helper, &tuple);

858

859

2

      json_builder_end_object (builder);

860

861

2

862

863

static void

864

450

invalid_chars_foreach_cb (IPuzCrossword *crossword,

865

                          IPuzCell      *cell,

866

                          IPuzCellCoord  coord,

867

                          gpointer       user_data)

868

869

450

  IPuzPuzzleFlags *flags = user_data;

870

  const gchar *solution;

871

  IPuzCharset *charset;

872

873

450

  if (!IPUZ_CELL_IS_GUESSABLE (cell))

874

128

    return;

875

876

  /* if we've already detected invalid chars, we can exit */

877

322

  if (*flags & IPUZ_PUZZLE_FLAG_INVALID_CHARS)

878

    return;

879

880

322

  solution = ipuz_cell_get_solution (cell);

881

322

  if (solution == NULL)

882

    return;

883

884

322

  charset = ipuz_puzzle_get_charset (IPUZ_PUZZLE (crossword));

885

886

644

  for (const gchar *ptr = solution; *ptr; ptr = g_utf8_next_char (ptr))

887

888

322

      gunichar c = g_utf8_get_char (ptr);

889

322

      if (ipuz_charset_get_char_count (charset, c) == 0)

890

891

          *flags |= IPUZ_PUZZLE_FLAG_INVALID_CHARS;

892

          return;

893

894

895

896

897

static IPuzPuzzleFlags

898

2

ipuz_crossword_get_flags (IPuzPuzzle *puzzle)

899

900

  IPuzCrosswordPrivate *priv;

901

  guint flags;

902

903

2

  priv = ipuz_crossword_get_instance_private (IPUZ_CROSSWORD (puzzle));

904

905

2

  flags = IPUZ_PUZZLE_CLASS (ipuz_crossword_parent_class)->get_flags (puzzle);

906

907

  /* Do we have any clues at all? */

908

2

  for (guint i = 0; i < ipuz_clue_sets_get_n_clue_sets (priv->clue_sets); i++)

909

910

      GArray *clues;

911

912

2

      clues = ipuz_clue_sets_get_clues (priv->clue_sets,

913

                                        ipuz_clue_sets_get_direction (priv->clue_sets, i));

914

2

      if (clues->len > 0)

915

916

2

          flags |= IPUZ_PUZZLE_FLAG_HAS_CLUES;

917

2

          break;

918

919

920

921

2

  if (priv->uses_extensions)

922

    flags |= IPUZ_PUZZLE_FLAG_USES_EXTENSIONS;

923

924

2

  if (priv->has_solution)

925

2

    flags |= IPUZ_PUZZLE_FLAG_HAS_SOLUTION;

926

927

2

  if (priv->has_saved)

928

    flags |= IPUZ_PUZZLE_FLAG_HAS_SAVED;

929

930

2

  ipuz_crossword_foreach_cell (IPUZ_CROSSWORD (puzzle),

931

                               invalid_chars_foreach_cb,

932

                               &flags);

933

934

2

  return flags;

935

936

937

/* Used for calculate_info */

938

typedef struct

939

940

  IPuzPuzzle *puzzle;

941

  IPuzPuzzleInfo *info;

942

  IPuzCharsetBuilder *solution_chars_builder;

943

  IPuzCharsetBuilder *clue_lengths_builder;

944

} InfoTuple;

945

946

static void

947

450

calculate_cells_foreach_cb (IPuzCrossword *crossword,

948

                            IPuzCell      *cell,

949

                            IPuzCellCoord  coord,

950

                            gpointer       user_data)

951

952

450

  InfoTuple *info_tuple = user_data;

953

954

450

  if (IPUZ_CELL_IS_BLOCK (cell))

955

128

    info_tuple->info->cell_stats.block_count ++;

956

322

  else if (IPUZ_CELL_IS_NORMAL (cell))

957

322

    info_tuple->info->cell_stats.normal_count ++;

958

  else if (IPUZ_CELL_IS_NULL (cell))

959

    info_tuple->info->cell_stats.null_count ++;

960

  else

961

    g_assert_not_reached ();

962

963

450

  if (IPUZ_CELL_IS_NORMAL (cell))

964

965

      const gchar *solution;

966

967

322

      solution = ipuz_cell_get_solution (cell);

968

969

322

      if (solution)

970

322

        ipuz_charset_builder_add_text (info_tuple->solution_chars_builder,

971

                                       solution);

972

973

450

974

975

static void

976

76

calculate_clues_foreach_cb (IPuzCrossword     *xword,

977

                            IPuzClueDirection  direction,

978

                            IPuzClue          *clue,

979

                            IPuzClueId         clue_id,

980

                            gpointer           user_data)

981

982

76

  InfoTuple *info_tuple = user_data;

983

  const GArray *cells;

984

985

  /* Only set this flag if there is text for a clue */

986

76

  if (ipuz_clue_get_clue_text (clue))

987

76

    info_tuple->info->flags |= IPUZ_PUZZLE_FLAG_HAS_CLUES;

988

989

76

  cells = ipuz_clue_get_cells (clue);

990

76

  if (cells)

991

76

    ipuz_charset_builder_add_character (info_tuple->clue_lengths_builder,

992

76

                                        (gunichar) cells->len);

993

76

994

995

static void

996

2

calculate_pangram (IPuzPuzzle     *puzzle,

997

                   IPuzPuzzleInfo *info)

998

999

  IPuzCharsetIter *iter;

1000

  IPuzCharset *charset;

1001

1002

2

  info->pangram_count = G_MAXUINT;

1003

1004

2

  charset = ipuz_puzzle_get_charset (puzzle);

1005

2

  for (iter = ipuz_charset_iter_first (charset);

1006

54

       iter;

1007

52

       iter = ipuz_charset_iter_next (iter))

1008

1009

      IPuzCharsetIterValue value;

1010

1011

52

      value = ipuz_charset_iter_get_value (iter);

1012

52

      info->pangram_count =

1013

52

        MIN (info->pangram_count, ipuz_charset_get_char_count (info->solution_chars, value.c));

1014

1015

1016

2

  if (info->pangram_count == G_MAXUINT)

1017

    info->pangram_count = 0;

1018

2

1019

1020

static void

1021

2

ipuz_crossword_calculate_info (IPuzPuzzle     *puzzle,

1022

                               IPuzPuzzleInfo *info)

1023

1024

  InfoTuple info_tuple;

1025

1026

2

  g_assert (IPUZ_IS_PUZZLE (puzzle));

1027

2

  g_assert (IPUZ_IS_PUZZLE_INFO (info));

1028

1029

2

  IPUZ_PUZZLE_CLASS (ipuz_crossword_parent_class)->calculate_info (puzzle, info);

1030

1031

2

  info_tuple.puzzle = puzzle;

1032

2

  info_tuple.info = info;

1033

2

  info_tuple.solution_chars_builder = ipuz_charset_builder_new ();

1034

2

  info_tuple.clue_lengths_builder = ipuz_charset_builder_new ();

1035

1036

2

  ipuz_crossword_foreach_cell (IPUZ_CROSSWORD (puzzle),

1037

                               calculate_cells_foreach_cb,

1038

                               &info_tuple);

1039

2

  info->solution_chars = ipuz_charset_builder_build (info_tuple.solution_chars_builder);

1040

1041

2

  ipuz_crossword_foreach_clue (IPUZ_CROSSWORD (puzzle),

1042

                               calculate_clues_foreach_cb,

1043

                               &info_tuple);

1044

2

  info->clue_lengths = ipuz_charset_builder_build (info_tuple.clue_lengths_builder);

1045

1046

2

  calculate_pangram (puzzle, info);

1047

2

  info->flags = ipuz_puzzle_get_flags (puzzle);

1048

2

1049

1050

/*

1051

 * Copying boards is painful. They don't exist on their own but refer

1052

 * to other portions of the crossword. There's not really a good way to

1053

 * just make fresh copies of cells, as they refer to styles and clues

1054

 * within the puzzle. We can copy the board and cells on the surface,

1055

 * then refix them up afterwards. Regardless of which, Boards don't

1056

 * exist outside the context of their Crossword in practice.

1057

*/

1058

static void

1059

2

ipuz_crossword_deep_clone_board (IPuzCrossword *src,

1060

                                 IPuzCrossword *dest)

1061

1062

  IPuzCrosswordPrivate *dest_priv;

1063

2

  GHashTable *styles = NULL;

1064

  guint row, column;

1065

1066

2

  dest_priv = ipuz_crossword_get_instance_private (dest);

1067

1068

2

  ipuz_board_resize (dest_priv->board, dest_priv->width, dest_priv->height);

1069

2

  g_object_get (G_OBJECT (dest),

1070

                "styles", &styles,

1071

                NULL);

1072

1073

29

  for (row = 0; row < (guint) dest_priv->height; row++)

1074

1075

476

      for (column = 0; column < (guint) dest_priv->width; column++)

1076

1077

449

          IPuzCellCoord coord = { .row = row, .column = column };

1078

          IPuzCell *src_cell, *dest_cell;

1079

          IPuzStyle *style;

1080

1081

449

          src_cell = ipuz_crossword_get_cell (src, coord);

1082

449

          dest_cell = ipuz_crossword_get_cell (dest, coord);

1083

1084

449

          dest_cell->cell_type = src_cell->cell_type;

1085

449

          dest_cell->number = src_cell->number;

1086

449

          dest_cell->label = g_strdup (src_cell->label);

1087

449

          dest_cell->solution = g_strdup (src_cell->solution);

1088

449

          dest_cell->initial_val = g_strdup (src_cell->initial_val);

1089

449

          dest_cell->saved_guess = g_strdup (src_cell->saved_guess);

1090

449

          dest_cell->style_name = g_strdup (src_cell->style_name);

1091

1092

449

          if (dest_cell->style_name && styles)

1093

1094

              style = g_hash_table_lookup (styles, dest_cell->style_name);

1095

              if (style)

1096

                dest_cell->style = ipuz_style_ref (style);

1097

1098

1099

          /* update the clues. We will have already copied the clues before we attempt to do this */

1100

449

	  if (dest_cell->clues == NULL)

1101

449

            dest_cell->clues = g_array_new (FALSE, TRUE, sizeof (IPuzClue *));

1102

1103

449

	  if (src_cell->clues)

1104

1105

673

	      for (guint i = 0; i < src_cell->clues->len; i++)

1106

1107

	          IPuzClueId clue_id;

1108

	          IPuzClue *src_clue, *dest_clue;

1109

1110

369

	          src_clue = g_array_index (src_cell->clues, IPuzClue *, i);

1111

369

		  clue_id.direction = src_clue->direction;

1112

369

	          clue_id.index = ipuz_crossword_find_clue (src, src_clue);

1113

369

	          dest_clue = ipuz_crossword_get_clue_by_id (dest, clue_id);

1114

369

	          g_array_append_val (dest_cell->clues, dest_clue);

1115

1116

1117

1118

          /* There's a chance the original crossword has a weird state

1119

           * with a style_name and an independent style. We keep that

1120

           * inconsistent state rather than trying to clean it up. */

1121

449

          if (dest_cell->style == NULL)

1122

449

            dest_cell->style = ipuz_style_copy (src_cell->style);

1123

1124

1125

2

1126

1127

static void

1128

2

ipuz_crossword_clone (IPuzPuzzle *src,

1129

                      IPuzPuzzle *dest)

1130

1131

  IPuzCrosswordPrivate *src_priv, *dest_priv;

1132

1133

2

  if (src == NULL)

1134

    return;

1135

1136

2

  g_assert (src != NULL);

1137

1138

2

  src_priv = ipuz_crossword_get_instance_private (IPUZ_CROSSWORD (src));

1139

2

  dest_priv = ipuz_crossword_get_instance_private (IPUZ_CROSSWORD (dest));

1140

1141

  /* Chain up to start to get the meta information */

1142

2

  IPUZ_PUZZLE_CLASS (ipuz_crossword_parent_class)->clone (src, dest);

1143

1144

2

  dest_priv->width = src_priv->width;

1145

2

  dest_priv->height = src_priv->height;

1146

2

  dest_priv->showenumerations = src_priv->showenumerations;

1147

2

  dest_priv->clue_placement = src_priv->clue_placement;

1148

1149

1150

2

  ipuz_clue_sets_clone (src_priv->clue_sets, dest_priv->clue_sets);

1151

2

  ipuz_crossword_deep_clone_board (IPUZ_CROSSWORD (src),

1152

                                   IPUZ_CROSSWORD (dest));

1153

2

  dest_priv->guesses = ipuz_guesses_copy (src_priv->guesses);

1154

1155

2

  dest_priv->uses_extensions = src_priv->uses_extensions;

1156

2

  dest_priv->has_solution = src_priv->has_solution;

1157

2

  dest_priv->has_saved = src_priv->has_saved;

1158

1159

1160

static const gchar *const *

1161

1

ipuz_crossword_get_kind_str (IPuzPuzzle *puzzle)

1162

1163

  static const char *kind_str[] =

1164

1165

      "http://ipuz.org/crossword#1",

1166

      NULL

1167

};

1168

1169

1

  return kind_str;

1170

1171

1172

1173

typedef struct

1174

1175

  gpointer old_style;

1176

  gpointer new_style;

1177

} StyleSwapTuple;

1178

1179

static void

1180

foreach_fixup_style (IPuzCrossword *crossword,

1181

                     IPuzCell      *cell,

1182

                     IPuzCellCoord  coord,

1183

                     gpointer       user_data)

1184

1185

  StyleSwapTuple *tuple;

1186

1187

  tuple = (StyleSwapTuple *) user_data;

1188

1189

  if (cell->style == tuple->old_style)

1190

    ipuz_cell_set_style (cell, tuple->new_style, NULL);

1191

1192

1193

static void

1194

3

ipuz_crossword_set_style (IPuzPuzzle  *puzzle,

1195

                          const gchar *style_name,

1196

                          IPuzStyle   *style)

1197

1198

  StyleSwapTuple tuple;

1199

1200

3

  tuple.old_style = ipuz_puzzle_get_style (puzzle, style_name);

1201

3

  tuple.new_style = style;

1202

1203

  /* old_style may be unreffed after this call. Do not do anything

1204

   * with it */

1205

3

  IPUZ_PUZZLE_CLASS (ipuz_crossword_parent_class)->set_style (puzzle, style_name, style);

1206

1207

3

  if (tuple.old_style != NULL)

1208

    ipuz_crossword_foreach_cell (IPUZ_CROSSWORD (puzzle),

1209

                                 foreach_fixup_style, &tuple);

1210

3

1211

1212

static gboolean

1213

3

ipuz_crossword_equal (IPuzPuzzle *puzzle_a,

1214

                      IPuzPuzzle *puzzle_b)

1215

1216

  IPuzCrosswordPrivate *priv_a, *priv_b;

1217

1218

3

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (puzzle_b), FALSE);

1219

1220

3

  priv_a = ipuz_crossword_get_instance_private (IPUZ_CROSSWORD (puzzle_a));

1221

3

  priv_b = ipuz_crossword_get_instance_private (IPUZ_CROSSWORD (puzzle_b));

1222

1223

  /* clue_sets can never be NULL because it is initialized in

1224

   * ipuz_crossword_init_clues */

1225

3

  if (! ipuz_clue_sets_equal (priv_a->clue_sets, priv_b->clue_sets))

1226

    return FALSE;

1227

1228

3

  return (priv_a->width == priv_b->width

1229

3

          && priv_a->height == priv_b->height

1230

3

          && priv_a->showenumerations == priv_b->showenumerations

1231

3

          && ipuz_board_equal (priv_a->board, priv_b->board)

1232

3

          && ipuz_guesses_equal (priv_a->guesses, priv_b->guesses)

1233

3

          && priv_a->uses_extensions == priv_b->uses_extensions

1234

3

          && priv_a->has_solution == priv_b->has_solution

1235

3

          && priv_a->has_saved == priv_b->has_saved

1236

3

          && priv_a->clue_placement == priv_b->clue_placement

1237

6

          && IPUZ_PUZZLE_CLASS (ipuz_crossword_parent_class)->equal (puzzle_a, puzzle_b));

1238

1239

1240

static gboolean

1241

588

ipuz_crossword_real_clue_continues_up (IPuzCrossword *self,

1242

                                       IPuzCellCoord  coord)

1243

1244

588

  if (coord.row > 0)

1245

1246

548

      IPuzCellCoord neighbor_coord = coord;

1247

      IPuzCell *neighbor_cell;

1248

548

      neighbor_coord.row --;

1249

548

      neighbor_cell = ipuz_crossword_get_cell (self, neighbor_coord);

1250

548

      return IPUZ_CELL_IS_NORMAL (neighbor_cell);

1251

1252

1253

40

  return FALSE;

1254

1255

1256

static gboolean

1257

564

ipuz_crossword_real_clue_continues_down (IPuzCrossword *self,

1258

                                         IPuzCellCoord  coord)

1259

1260

  IPuzCrosswordPrivate *priv;

1261

1262

564

  priv = ipuz_crossword_get_instance_private (self);

1263

1264

564

  if (coord.row < (guint)priv->height - 1)

1265

1266

530

      IPuzCellCoord neighbor_coord = coord;

1267

      IPuzCell *neighbor_cell;

1268

530

      neighbor_coord.row ++;

1269

530

      neighbor_cell = ipuz_crossword_get_cell (self, neighbor_coord);

1270

530

      return IPUZ_CELL_IS_NORMAL (neighbor_cell);

1271

1272

1273

34

  return FALSE;

1274

1275

1276

static gboolean

1277

515

ipuz_crossword_real_clue_continues_left (IPuzCrossword *self,

1278

                                         IPuzCellCoord  coord)

1279

1280

515

  if (coord.column > 0)

1281

1282

476

      IPuzCellCoord neighbor_coord = coord;

1283

      IPuzCell *neighbor_cell;

1284

476

      neighbor_coord.column --;

1285

476

      neighbor_cell = ipuz_crossword_get_cell (self, neighbor_coord);

1286

476

      return IPUZ_CELL_IS_NORMAL (neighbor_cell);

1287

1288

1289

39

  return FALSE;

1290

1291

1292

static gboolean

1293

544

ipuz_crossword_real_clue_continues_right (IPuzCrossword *self,

1294

                                          IPuzCellCoord  coord)

1295

1296

  IPuzCrosswordPrivate *priv;

1297

1298

544

  priv = ipuz_crossword_get_instance_private (self);

1299

1300

544

  if (coord.column < (guint)priv->width - 1)

1301

1302

508

      IPuzCellCoord neighbor_coord = coord;

1303

      IPuzCell *neighbor_cell;

1304

508

      neighbor_coord.column ++;

1305

508

      neighbor_cell = ipuz_crossword_get_cell (self, neighbor_coord);

1306

508

      return IPUZ_CELL_IS_NORMAL (neighbor_cell);

1307

1308

1309

36

  return FALSE;

1310

1311

1312

static void

1313

17

ipuz_crossword_real_mirror_cell (IPuzCrossword      *self,

1314

                                 IPuzCellCoord       src_coord,

1315

                                 IPuzCellCoord       dest_coord,

1316

                                 IPuzSymmetry        symmetry,

1317

                                 IPuzSymmetryOffset  symmetry_offset)

1318

1319

  IPuzCell *src, *dest;

1320

1321

17

  src = ipuz_crossword_get_cell (self, src_coord);

1322

17

  dest = ipuz_crossword_get_cell (self, dest_coord);

1323

1324

17

  ipuz_cell_set_cell_type (dest, ipuz_cell_get_cell_type (src));

1325

17

1326

1327

static gboolean

1328

451

ipuz_crossword_real_check_mirror (IPuzCrossword      *self,

1329

                                  IPuzCellCoord       src_coord,

1330

                                  IPuzCellCoord       target_coord,

1331

                                  IPuzSymmetry        symmetry,

1332

                                  IPuzSymmetryOffset  symmetry_offset)

1333

1334

  IPuzCell *src, *target;

1335

1336

451

  src = ipuz_crossword_get_cell (self, src_coord);

1337

451

  target = ipuz_crossword_get_cell (self, target_coord);

1338

1339

451

  return (ipuz_cell_get_cell_type (src) == ipuz_cell_get_cell_type (target));

1340

1341

1342

static void

1343

3

ipuz_crossword_real_fix_symmetry  (IPuzCrossword *self,

1344

                                   IPuzSymmetry   symmetry,

1345

                                   GArray        *coords)

1346

1347

  IPuzCrosswordPrivate *priv;

1348

1349

3

  priv = ipuz_crossword_get_instance_private (self);

1350

1351

  /* Nothing to do */

1352

3

  if (symmetry == IPUZ_SYMMETRY_NONE)

1353

    return;

1354

1355

  /* Quarter-symmetric only makes sense if we're square */

1356

3

  if (priv->width != priv->height)

1357

    g_return_if_fail (symmetry != IPUZ_SYMMETRY_ROTATIONAL_QUARTER);

1358

1359

10

  for (guint i = 0; i < coords->len; i++)

1360

1361

      IPuzCellCoord coord;

1362

      IPuzCellCoord mirror_coord;

1363

1364

7

      coord = g_array_index (coords, IPuzCellCoord, i);

1365

1366

7

      mirror_coord = ipuz_symmetry_calculate (coord, priv->width, priv->height,

1367

                                              symmetry, IPUZ_SYMMETRY_OFFSET_OPPOSITE);

1368

7

      ipuz_crossword_mirror_cell (self, coord, mirror_coord, symmetry, IPUZ_SYMMETRY_OFFSET_OPPOSITE);

1369

1370

      /* Add the other two points as well */

1371

7

      if (symmetry == IPUZ_SYMMETRY_ROTATIONAL_QUARTER ||

1372

          symmetry == IPUZ_SYMMETRY_MIRRORED)

1373

1374

5

          mirror_coord = ipuz_symmetry_calculate (coord, priv->width, priv->height,

1375

                                                  symmetry, IPUZ_SYMMETRY_OFFSET_CW_ADJACENT);

1376

5

          ipuz_crossword_mirror_cell (self, coord, mirror_coord, symmetry, IPUZ_SYMMETRY_OFFSET_CW_ADJACENT);

1377

1378

5

          mirror_coord = ipuz_symmetry_calculate (coord, priv->width, priv->height,

1379

                                                  symmetry, IPUZ_SYMMETRY_OFFSET_CCW_ADJACENT);

1380

5

          ipuz_crossword_mirror_cell (self, coord, mirror_coord, symmetry, IPUZ_SYMMETRY_OFFSET_CCW_ADJACENT);

1381

1382

1383

1384

1385

static void

1386

5

ipuz_crossword_real_fix_numbering (IPuzCrossword *self)

1387

1388

  IPuzCrosswordPrivate *priv;

1389

  guint row, col;

1390

5

  gint number = 1;

1391

1392

5

  priv = ipuz_crossword_get_instance_private (self);

1393

1394

66

  for (row = 0; row < (guint) priv->height; row++)

1395

1396

900

      for (col = 0; col < (guint) priv->width; col++)

1397

1398

839

          IPuzCellCoord coord = { .row = row, .column = col };

1399

          IPuzCell *cell;

1400

1401

839

          cell = ipuz_crossword_get_cell (self, coord);

1402

1403

839

          if (! IPUZ_CELL_IS_NORMAL (cell))

1404

201

            continue;

1405

1406

          /* Clear the label */

1407

638

          ipuz_cell_set_label (cell, NULL);

1408

1409

1196

          if ((!ipuz_crossword_clue_continues_up (self, coord) && ipuz_crossword_clue_continues_down (self, coord)) ||

1410

779

              (!ipuz_crossword_clue_continues_left (self, coord) && ipuz_crossword_clue_continues_right (self, coord)))

1411

1412

150

              ipuz_cell_set_number (cell, number);

1413

150

              number++;

1414

1415

          else

1416

1417

488

              ipuz_cell_set_number (cell, 0);

1418

1419

1420

1421

5

1422

1423

static void

1424

4

match_clue_sets (IPuzClueSets *src_clue_sets,

1425

                 IPuzClueSets *dest_clue_sets)

1426

1427

4

  g_assert (src_clue_sets);

1428

4

  g_assert (dest_clue_sets);

1429

1430

10

  for (guint n = 0; n < ipuz_clue_sets_get_n_clue_sets (src_clue_sets); n++)

1431

1432

      IPuzClueDirection direction;

1433

      GArray *src_clues;

1434

      GArray *dest_clues;

1435

1436

6

      direction = ipuz_clue_sets_get_direction (src_clue_sets, n);

1437

6

      src_clues = ipuz_clue_sets_get_clues (src_clue_sets, direction);

1438

6

      dest_clues = ipuz_clue_sets_get_clues (dest_clue_sets, direction);

1439

1440

6

      g_assert (src_clues != NULL);

1441

6

      if (dest_clues == NULL)

1442

        continue;

1443

1444

98

      for (guint i = 0; i < src_clues->len; i++)

1445

1446

          IPuzClue *src_clue;

1447

          const GArray *src_cells;

1448

1449

92

          src_clue = g_array_index (src_clues, IPuzClue *, i);

1450

92

          src_cells = ipuz_clue_get_cells (src_clue);

1451

1452

1939

          for (guint j = 0; j < dest_clues->len; j++)

1453

1454

              IPuzClue *dest_clue;

1455

              const GArray *dest_cells;

1456

1457

1847

              dest_clue = g_array_index (dest_clues, IPuzClue *, j);

1458

1847

              dest_cells = ipuz_clue_get_cells (dest_clue);

1459

1460

1847

              if ((src_cells->len == dest_cells->len) &&

1461

416

                  (memcmp (src_cells->data, dest_cells->data, src_cells->len * sizeof (IPuzCellCoord)) == 0))

1462

1463

73

                  IPuzEnumeration *enumeration = ipuz_clue_get_enumeration (src_clue);

1464

                  /* We don't need to set the label, number, direction, or

1465

                   * location as we will have built that already in

1466

                   * fix_clues () */

1467

73

                  ipuz_clue_set_clue_text (dest_clue, ipuz_clue_get_clue_text (src_clue));

1468

73

                  ipuz_clue_set_enumeration (dest_clue, enumeration);

1469

73

                  ipuz_enumeration_unref (enumeration);

1470

1471

1472

1473

1474

4

1475

1476

static void

1477

4

ipuz_crossword_real_fix_clues (IPuzCrossword *self)

1478

1479

  IPuzCrosswordPrivate *priv;

1480

4

  g_autoptr (IPuzClueSets) old_clue_sets = NULL;

1481

1482

4

  g_return_if_fail (IPUZ_IS_CROSSWORD (self));

1483

1484

4

  priv = ipuz_crossword_get_instance_private (self);

1485

1486

  /* Keep the old clue_set around to copy over clue labels and

1487

   * enumerations. This comparison is unfortunately n^2, but I don't

1488

   * think there's any way around that. */

1489

4

  old_clue_sets = priv->clue_sets;

1490

4

  priv->clue_sets = NULL;

1491

4

  ipuz_crossword_init_clues (self);

1492

1493

50

  for (guint row = 0; row < (guint) priv->height; row++)

1494

1495

660

      for (guint col = 0; col < (guint) priv->width; col++)

1496

1497

          IPuzCell *cell;

1498

614

          IPuzCellCoord coord = { .row = row, .column = col };

1499

          gint number;

1500

1501

614

          cell = ipuz_crossword_get_cell (self, coord);

1502

	  /* Clear out the old clues */

1503

614

	  ipuz_cell_clear_clues (cell);

1504

614

          number = ipuz_cell_get_number (cell);

1505

1506

614

          if (number > 0)

1507

1508

              IPuzClue *across_clue;

1509

              IPuzClue *down_clue;

1510

1511

120

              across_clue = calculate_clue (self, IPUZ_CLUE_DIRECTION_ACROSS, coord, number);

1512

120

              down_clue = calculate_clue (self, IPUZ_CLUE_DIRECTION_DOWN, coord, number);

1513

1514

120

              if (across_clue)

1515

63

                ipuz_clue_sets_append_clue (priv->clue_sets, IPUZ_CLUE_DIRECTION_ACROSS, across_clue);

1516

120

              if (down_clue)

1517

64

                ipuz_clue_sets_append_clue (priv->clue_sets, IPUZ_CLUE_DIRECTION_DOWN, down_clue);

1518

1519

1520

1521

1522

  /* Set up all the cells for the clues we just created */

1523

4

  ipuz_crossword_fixup_clues (self);

1524

4

  match_clue_sets (old_clue_sets, priv->clue_sets);

1525

1526

1527

1528

static void

1529

86

ensure_enumeration (IPuzCrossword     *xword,

1530

                    IPuzClueDirection  direction,

1531

                    IPuzClue          *clue,

1532

                    IPuzClueId         clue_id,

1533

                    gpointer           user_data)

1534

1535

  IPuzEnumeration *enumeration;

1536

  const GArray *cells;

1537

86

  g_autofree gchar *str = NULL;

1538

1539

86

  enumeration = ipuz_clue_get_enumeration (clue);

1540

86

  if (enumeration != NULL)

1541

1542

86

      ipuz_enumeration_unref (enumeration);

1543

86

      return;

1544

1545

1546

  /* create an enumeration for clue as if it had no deliminators */

1547

  cells = ipuz_clue_get_cells (clue);

1548

  str = g_strdup_printf ("%u", cells?cells->len:0);

1549

  enumeration = ipuz_enumeration_new (str, IPUZ_VERBOSITY_STANDARD);

1550

1551

  ipuz_clue_set_enumeration (clue, enumeration);

1552

  ipuz_enumeration_unref (enumeration);

1553

1554

1555

static void

1556

3

ipuz_crossword_real_fix_enumerations (IPuzCrossword *self)

1557

1558

3

  gboolean showenumerations = FALSE;

1559

1560

4

  g_return_if_fail (IPUZ_IS_CROSSWORD (self));

1561

1562

3

  g_object_get (self,

1563

                "showenumerations", &showenumerations,

1564

                NULL);

1565

1566

3

  if (!showenumerations)

1567

1

    return;

1568

1569

2

  ipuz_crossword_foreach_clue (self, ensure_enumeration, NULL);

1570

1571

1572

static void

1573

569

foreach_fix_styles (IPuzCrossword *crossword,

1574

                    IPuzCell      *cell,

1575

                    IPuzCellCoord  coord,

1576

                    gpointer       user_data)

1577

1578

  IPuzStyle *style;

1579

1580

569

  style = ipuz_cell_get_style (cell);

1581

569

  if (style && ipuz_style_is_empty (style))

1582

    ipuz_cell_set_style (cell, NULL, NULL);

1583

569

1584

1585

static void

1586

7

ipuz_crossword_real_fix_styles (IPuzCrossword *self)

1587

1588

7

  g_return_if_fail (IPUZ_IS_CROSSWORD (self));

1589

1590

7

  ipuz_crossword_foreach_cell (self, foreach_fix_styles, NULL);

1591

1592

1593

static void

1594

3

ipuz_crossword_real_fix_all (IPuzCrossword *self,

1595

                             const gchar   *first_attribute_name,

1596

                             va_list        var_args)

1597

1598

  const gchar *attribute_name;

1599

3

  IPuzSymmetry symmetry = IPUZ_SYMMETRY_NONE;

1600

3

  GArray *symmetry_coords = NULL; /* We don't own this */

1601

  va_list var_args_copy;

1602

1603

3

  va_copy (var_args_copy, var_args);

1604

3

  attribute_name = first_attribute_name;

1605

1606

7

  while (attribute_name)

1607

1608

4

      if (! g_strcmp0 (attribute_name, "symmetry-coords"))

1609

1610

2

          if (symmetry_coords != NULL)

1611

1612

              g_warning ("symmetry-coords set multiple times");

1613

              goto out;

1614

1615

2

          symmetry_coords = va_arg (var_args_copy, GArray *);

1616

1617

2

      else if (! g_strcmp0 (attribute_name, "symmetry"))

1618

1619

2

          symmetry = va_arg (var_args_copy, IPuzSymmetry);

1620

1621

1622

4

      attribute_name = va_arg (var_args_copy, const gchar *);

1623

1624

1625

  /* Apply fixes to the puzzle */

1626

3

  if (symmetry_coords != NULL)

1627

2

    ipuz_crossword_fix_symmetry (self, symmetry, symmetry_coords);

1628

3

  ipuz_crossword_fix_numbering (self);

1629

3

  ipuz_crossword_fix_clues (self);

1630

3

  ipuz_crossword_fix_enumerations (self);

1631

3

  ipuz_crossword_fix_styles (self);

1632

1633

3

 out:

1634

3

  va_end (var_args_copy);

1635

3

1636

1637

/**

1638

 * Public Methods

1639

*/

1640

1641

IPuzCrossword *

1642

ipuz_crossword_new (void)

1643

1644

  IPuzCrossword *xword;

1645

1646

  xword = g_object_new (IPUZ_TYPE_CROSSWORD, NULL);

1647

1648

  return xword;

1649

1650

1651

guint

1652

246

ipuz_crossword_get_width (IPuzCrossword *self)

1653

1654

  IPuzCrosswordPrivate *priv;

1655

1656

246

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), 0);

1657

1658

246

  priv = ipuz_crossword_get_instance_private (self);

1659

1660

246

  return priv->width;

1661

1662

1663

1664

guint

1665

229

ipuz_crossword_get_height (IPuzCrossword *self)

1666

1667

  IPuzCrosswordPrivate *priv;

1668

1669

229

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), 0);

1670

1671

229

  priv = ipuz_crossword_get_instance_private (self);

1672

1673

229

  return priv->height;

1674

1675

1676

1677

static gboolean

1678

38

ipuz_crossword_real_set_size (IPuzCrossword *self,

1679

                              gint           width,

1680

                              gint           height)

1681

1682

  IPuzCrosswordPrivate *priv;

1683

1684

38

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), FALSE);

1685

1686

38

  priv = ipuz_crossword_get_instance_private (self);

1687

1688

38

  if (priv->width == width && priv->height == height)

1689

1

    return FALSE;

1690

1691

37

  priv->width = width;

1692

37

  priv->height = height;

1693

1694

37

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

1695

37

    ipuz_board_resize (priv->board, width, height);

1696

1697

37

  return TRUE;

1698

1699

1700

void

1701

6

ipuz_crossword_set_size   (IPuzCrossword *self,

1702

                           gint           width,

1703

                           gint           height)

1704

1705

6

  g_return_if_fail (IPUZ_IS_CROSSWORD (self));

1706

6

  g_return_if_fail (width > 0 && height > 0);

1707

1708

6

  g_object_freeze_notify (G_OBJECT (self));

1709

6

  if (ipuz_crossword_real_set_size (self, width, height))

1710

1711

5

      g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_WIDTH]);

1712

5

      g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_HEIGHT]);

1713

1714

6

  g_object_thaw_notify (G_OBJECT (self));

1715

1716

1717

IPuzBoard *

1718

13

ipuz_crossword_get_board (IPuzCrossword *self)

1719

1720

  IPuzCrosswordPrivate *priv;

1721

1722

13

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), NULL);

1723

1724

13

  priv = ipuz_crossword_get_instance_private (self);

1725

1726

13

  return priv->board;

1727

1728

1729

static gboolean

1730

ipuz_crossword_validate_guesses (IPuzCrossword *self,

1731

                                 IPuzGuesses   *guesses)

1732

1733

  IPuzCrosswordPrivate *priv;

1734

  guint row, col;

1735

1736

  priv = ipuz_crossword_get_instance_private (self);

1737

1738

  if ((guint) priv->width != ipuz_guesses_get_width (guesses) ||

1739

      (guint) priv->height != ipuz_guesses_get_height (guesses))

1740

    return FALSE;

1741

1742

  for (row = 0; row < (guint) priv->height; row++)

1743

1744

      for (col = 0; col < (guint) priv->width; col++)

1745

1746

          IPuzCell *cell;

1747

          IPuzCellCellType guess_type;

1748

          IPuzCellCoord coord = { .row = row, .column = col };

1749

1750

          cell = ipuz_crossword_get_cell (self, coord);

1751

          guess_type = ipuz_guesses_get_cell_type (guesses, coord);

1752

1753

          /* We check to make sure that if the cell is guessable, we

1754

           * can write to it. We ignore the remainder of the cells. */

1755

          if (IPUZ_CELL_IS_GUESSABLE (cell) &&

1756

              guess_type != IPUZ_CELL_NORMAL)

1757

            return FALSE;

1758

1759

1760

  return TRUE;

1761

1762

1763

gboolean

1764

ipuz_crossword_set_guesses (IPuzCrossword *self,

1765

                            IPuzGuesses   *guesses)

1766

1767

  IPuzCrosswordPrivate *priv;

1768

1769

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), FALSE);

1770

1771

  priv = ipuz_crossword_get_instance_private (self);

1772

1773

  if (guesses)

1774

1775

      if (! ipuz_crossword_validate_guesses (self, guesses))

1776

        return FALSE;

1777

      ipuz_guesses_ref (guesses);

1778

1779

1780

  g_clear_pointer (&priv->guesses, ipuz_guesses_unref);

1781

  priv->guesses = guesses;

1782

  g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_GUESSES]);

1783

1784

  return TRUE;

1785

1786

1787

IPuzGuesses *

1788

ipuz_crossword_get_guesses (IPuzCrossword *self)

1789

1790

  IPuzCrosswordPrivate *priv;

1791

1792

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), NULL);

1793

1794

  priv = ipuz_crossword_get_instance_private (self);

1795

1796

  return priv->guesses;

1797

1798

1799

/* Convenience function. */

1800

IPuzCell *

1801

17939

ipuz_crossword_get_cell (IPuzCrossword *self,

1802

                         IPuzCellCoord  coord)

1803

1804

  IPuzCrosswordPrivate *priv;

1805

1806

17939

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), NULL);

1807

1808

17939

  priv = ipuz_crossword_get_instance_private (self);

1809

17939

  g_return_val_if_fail (priv->board != NULL, NULL);

1810

1811

17939

  return ipuz_board_get_cell (priv->board, coord);

1812

1813

1814

1815

/* Foreach functions */

1816

void

1817

4

ipuz_crossword_foreach_clue (IPuzCrossword                *self,

1818

                             IPuzCrosswordForeachClueFunc  func,

1819

                             gpointer                      data)

1820

1821

  IPuzCrosswordPrivate *priv;

1822

1823

4

  g_return_if_fail (IPUZ_IS_CROSSWORD (self));

1824

1825

4

  priv = ipuz_crossword_get_instance_private (IPUZ_CROSSWORD (self));

1826

1827

12

  for (guint i = 0; i < ipuz_clue_sets_get_n_clue_sets (priv->clue_sets); i++)

1828

1829

      IPuzClueDirection direction;

1830

      GArray *clues;

1831

1832

8

      direction = ipuz_clue_sets_get_direction (priv->clue_sets, i);

1833

8

      clues = ipuz_clue_sets_get_clues (priv->clue_sets, direction);

1834

1835

170

      for (guint j = 0; j < clues->len; j++)

1836

1837

          IPuzClue *clue;

1838

162

          IPuzClueId clue_id = {

1839

            .direction = direction,

1840

            .index = j,

1841

};

1842

1843

162

          clue = g_array_index (clues, IPuzClue *, j);

1844

162

          (func) (self, direction, clue, clue_id, data);

1845

1846

1847

1848

1849

void

1850

11

ipuz_crossword_foreach_cell (IPuzCrossword                *self,

1851

                             IPuzCrosswordForeachCellFunc  func,

1852

                             gpointer                      user_data)

1853

1854

  IPuzCrosswordPrivate *priv;

1855

  guint row, col;

1856

1857

11

  g_return_if_fail (IPUZ_IS_CROSSWORD (self));

1858

1859

11

  priv = ipuz_crossword_get_instance_private (self);

1860

1861

123

  for (row = 0; row < (guint) priv->height; row++)

1862

1863

1581

      for (col = 0; col < (guint) priv->width; col++)

1864

1865

          IPuzCell *cell;

1866

1469

          IPuzCellCoord coord = { .row = row, .column = col };

1867

1868

1469

          cell = ipuz_crossword_get_cell (self, coord);

1869

1469

          (func) (self, cell, coord, user_data);

1870

1871

1872

1873

1874

guint

1875

33

ipuz_crossword_get_n_clue_sets (IPuzCrossword *self)

1876

1877

  IPuzCrosswordPrivate *priv;

1878

1879

33

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), 0);

1880

1881

33

  priv = ipuz_crossword_get_instance_private (self);

1882

1883

33

  return ipuz_clue_sets_get_n_clue_sets (priv->clue_sets);

1884

1885

1886

IPuzClueDirection

1887

15

ipuz_crossword_clue_set_get_dir (IPuzCrossword *self,

1888

                                 guint          index)

1889

1890

  IPuzCrosswordPrivate *priv;

1891

1892

15

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), IPUZ_CLUE_DIRECTION_NONE);

1893

1894

15

  priv = ipuz_crossword_get_instance_private (self);

1895

1896

15

  return ipuz_clue_sets_get_direction (priv->clue_sets, index);

1897

1898

1899

const gchar *

1900

ipuz_crossword_clue_set_get_label (IPuzCrossword     *self,

1901

                                   IPuzClueDirection  direction)

1902

1903

  IPuzCrosswordPrivate *priv;

1904

1905

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), NULL);

1906

1907

  priv = ipuz_crossword_get_instance_private (self);

1908

1909

  return ipuz_clue_sets_get_label (priv->clue_sets, direction);

1910

1911

1912

GArray *

1913

995

ipuz_crossword_get_clues (IPuzCrossword     *self,

1914

                          IPuzClueDirection  direction)

1915

1916

  IPuzCrosswordPrivate *priv;

1917

1918

995

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), NULL);

1919

1920

995

  priv = ipuz_crossword_get_instance_private (self);

1921

1922

995

  return ipuz_clue_sets_get_clues (priv->clue_sets, direction);

1923

1924

1925

IPuzClueId

1926

ipuz_crossword_get_clue_id (IPuzCrossword  *self,

1927

                            const IPuzClue *clue)

1928

1929

  IPuzClueId id = {

1930

    .direction = IPUZ_CLUE_DIRECTION_NONE,

1931

    .index = 0,

1932

};

1933

1934

  if (clue)

1935

1936

      gboolean found = FALSE;

1937

      GArray *clues;

1938

      guint i;

1939

1940

      clues = ipuz_crossword_get_clues (self, clue->direction);

1941

      if (clues == NULL)

1942

        return id;

1943

1944

      for (i = 0; i < clues->len; i++)

1945

1946

          IPuzClue *tmp_clue = g_array_index (clues, IPuzClue *, i);

1947

          if (ipuz_clue_equal (clue, tmp_clue))

1948

1949

              found = TRUE;

1950

              break;

1951

1952

1953

1954

      if (found)

1955

1956

          id.direction = clue->direction;

1957

          id.index = i;

1958

1959

1960

1961

  return id;

1962

1963

1964

IPuzClue *

1965

369

ipuz_crossword_get_clue_by_id (IPuzCrossword *self,

1966

                               IPuzClueId     clue_id)

1967

1968

  GArray *clues;

1969

1970

369

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), NULL);

1971

369

  g_return_val_if_fail (! IPUZ_CLUE_ID_IS_UNSET (clue_id), NULL);

1972

1973

369

  clues = ipuz_crossword_get_clues (self, clue_id.direction);

1974

1975

369

  if (clues && clue_id.index < clues->len)

1976

369

    return g_array_index (clues, IPuzClue *, clue_id.index);

1977

1978

  return NULL;

1979

1980

1981

1982

static void

1983

2

unlink_clue_from_cells (IPuzCrossword *self,

1984

                        IPuzClue      *clue)

1985

1986

2

  if (clue->cells == NULL)

1987

    return;

1988

1989

28

  for (guint i = 0; i < clue->cells->len; i++)

1990

1991

      IPuzCell *cell;

1992

      IPuzCellCoord coord;

1993

1994

26

      coord = g_array_index (clue->cells, IPuzCellCoord, i);

1995

26

      cell = ipuz_crossword_get_cell (self, coord);

1996

26

      if (cell)

1997

26

        ipuz_cell_clear_clue_direction (cell, clue->direction);

1998

1999

2000

2001

void

2002

2

ipuz_crossword_unlink_clue (IPuzCrossword *self,

2003

                            IPuzClue      *clue)

2004

2005

  IPuzCrosswordPrivate *priv;

2006

2007

2

  g_return_if_fail (IPUZ_IS_CROSSWORD (self));

2008

2

  g_return_if_fail (clue != NULL);

2009

2010

2

  priv = ipuz_crossword_get_instance_private (self);

2011

2012

  //  g_warning ("this function won't work correctly until we add refcounting to clues\n");

2013

2

  unlink_clue_from_cells (self, clue);

2014

2

  ipuz_clue_sets_remove_clue (priv->clue_sets, clue->direction, clue, TRUE);

2015

2016

2017

guint

2018

ipuz_crossword_get_n_clues (IPuzCrossword     *self,

2019

                            IPuzClueDirection  direction)

2020

2021

  GArray *clues;

2022

2023

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), 0);

2024

2025

  clues = ipuz_crossword_get_clues (self, direction);

2026

  if (clues)

2027

    return clues->len;

2028

2029

  return 0;

2030

2031

2032

guint

2033

369

ipuz_crossword_find_clue (IPuzCrossword *self,

2034

                          IPuzClue      *clue)

2035

2036

369

  GArray *clues = NULL;

2037

2038

369

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), 0);

2039

369

  g_return_val_if_fail (clue != NULL, 0);

2040

2041

369

  clues = ipuz_crossword_get_clues (self, clue->direction);

2042

2043

4222

  for (guint i = 0; i < clues->len; i ++)

2044

2045

4222

      IPuzClue *tmp_clue = g_array_index (clues, IPuzClue *, i);

2046

4222

      if (ipuz_clue_equal (clue, tmp_clue))

2047

369

        return i;

2048

2049

2050

  return 0;

2051

2052

2053

static gchar *

2054

ipuz_crossword_get_string (IPuzCrossword *self,

2055

                           IPuzClueId     clue_id,

2056

                           gboolean       guesses)

2057

2058

  IPuzCrosswordPrivate *priv;

2059

  IPuzClue *clue;

2060

  const GArray *cells;

2061

  GString *string;

2062

  guint i;

2063

2064

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), NULL);

2065

2066

  priv = ipuz_crossword_get_instance_private (self);

2067

  clue = ipuz_crossword_get_clue_by_id (self, clue_id);

2068

2069

  if (clue == NULL)

2070

    return NULL;

2071

2072

  string = g_string_new (NULL);

2073

  cells = ipuz_clue_get_cells (clue);

2074

  for (i = 0; i < cells->len; i++)

2075

2076

      IPuzCellCoord coord;

2077

      const char *solution = NULL;

2078

2079

      coord = g_array_index (cells, IPuzCellCoord, i);

2080

      if (guesses)

2081

2082

          solution = ipuz_guesses_get_guess (priv->guesses, coord);

2083

2084

      else

2085

2086

          IPuzCell *cell;

2087

2088

          cell = ipuz_crossword_get_cell (self, coord);

2089

          solution = ipuz_cell_get_solution (cell);

2090

2091

2092

      if (solution && solution[0] !='\0')

2093

        g_string_append (string, solution);

2094

      else

2095

        g_string_append (string, "?");

2096

2097

2098

  return g_string_free (string, FALSE);

2099

2100

2101

2102

/**

2103

 * ipuz_crossword_get_clue_string_by_id:

2104

 * @self: An 'IPuzCrossword'

2105

 * @direction: Direction of the clue

2106

 * @number: index of the clue

2107

2108

 * Returns a string containing the solution of the puzzle for a given

2109

 * clue. This string will have '?' characterd embedded within it if

2110

 * there are cells without solutions set yet.

2111

2112

 * Returns: The solution for the puzzle for Clue, or %NULL

2113

**/

2114

gchar *

2115

ipuz_crossword_get_clue_string_by_id (IPuzCrossword *self,

2116

                                      IPuzClueId     clue_id)

2117

2118

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), NULL);

2119

2120

  return ipuz_crossword_get_string (self, clue_id, FALSE);

2121

2122

2123

/**

2124

 * ipuz_crossword_get_guess_string_by_id:

2125

 * @self: An 'IPuzCrossword'

2126

 * @direction: Direction of the clue

2127

 * @number: index of the clue

2128

2129

 * Returns a string containing the guess in the puzzle for a given

2130

 * clue. This string will have '?' characterd embedded within it if

2131

 * there are cells not completely filled out.

2132

2133

 * Returns: The solution for the puzzle for Clue, or %NULL

2134

**/

2135

gchar *

2136

ipuz_crossword_get_guess_string_by_id (IPuzCrossword *self,

2137

                                       IPuzClueId     clue_id)

2138

2139

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), NULL);

2140

2141

  return ipuz_crossword_get_string (self, clue_id, TRUE);

2142

2143

2144

/**

2145

 * ipuz_crossword_clue_guessed:

2146

 * @self:  An 'IPuzCrossword'

2147

 * @clue: The clue to check

2148

2149

 * Check to see if every field in the clue is guessed. This doesn't

2150

 * account for the correctness of the clue

2151

2152

 * Returns: %TRUE, if every field in the clue is guessed.

2153

**/

2154

gboolean

2155

ipuz_crossword_clue_guessed (IPuzCrossword *self,

2156

                             IPuzClue      *clue,

2157

                             gboolean      *correct)

2158

2159

  IPuzCrosswordPrivate *priv;

2160

  const GArray *cells;

2161

  guint i;

2162

  gboolean guessed = TRUE;

2163

2164

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), FALSE);

2165

  g_return_val_if_fail (clue != NULL, FALSE);

2166

2167

  priv = ipuz_crossword_get_instance_private (self);

2168

  cells = ipuz_clue_get_cells (clue);

2169

2170

  if (cells == NULL || cells->len == 0)

2171

    return FALSE;

2172

  if (priv->guesses == NULL)

2173

    return FALSE;

2174

2175

  if (correct)

2176

    *correct = TRUE;

2177

2178

  for (i = 0; i < cells->len; i++)

2179

2180

      IPuzCellCoord coord;

2181

      IPuzCell *cell;

2182

      const char *guess = NULL;

2183

      const char *solution = NULL;

2184

2185

      coord = g_array_index (cells, IPuzCellCoord, i);

2186

      cell = ipuz_crossword_get_cell (self, coord);

2187

2188

      if (ipuz_cell_get_initial_val (cell))

2189

        continue;

2190

      guess = ipuz_guesses_get_guess (priv->guesses, coord);

2191

      solution = ipuz_cell_get_solution (cell);

2192

2193

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

2194

        guessed = FALSE;

2195

      if (correct)

2196

        *correct = !g_strcmp0 (solution, guess) && *correct;

2197

2198

2199

  return guessed;

2200

2201

2202

IPuzClue *

2203

2

ipuz_crossword_find_clue_by_number (IPuzCrossword     *self,

2204

                                    IPuzClueDirection  direction,

2205

                                    gint               number)

2206

2207

2

  GArray *clues = NULL;

2208

2209

2

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), NULL);

2210

2211

2

  clues = ipuz_crossword_get_clues (self, direction);

2212

2213

6

  for (guint i = 0; i < clues->len; i ++)

2214

2215

      IPuzClue *clue;

2216

6

      clue = g_array_index (clues, IPuzClue *, i);

2217

6

      if (clue->number == number)

2218

2

        return clue;

2219

2220

  return NULL;

2221

2222

2223

IPuzClue *

2224

ipuz_crossword_find_clue_by_label (IPuzCrossword     *self,

2225

                                   IPuzClueDirection  direction,

2226

                                   const gchar       *label)

2227

2228

  GArray *clues = NULL;

2229

2230

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), NULL);

2231

  g_return_val_if_fail (label != NULL, NULL);

2232

2233

  clues = ipuz_crossword_get_clues (self, direction);

2234

2235

  for (guint i = 0; i < clues->len; i ++)

2236

2237

      IPuzClue *clue;

2238

      clue = g_array_index (clues, IPuzClue *, i);

2239

      if (g_strcmp0 (label, clue->label) == 0)

2240

        return clue;

2241

2242

  return NULL;

2243

2244

2245

IPuzClue *

2246

240

ipuz_crossword_find_clue_by_coord (IPuzCrossword     *self,

2247

                                   IPuzClueDirection  direction,

2248

                                   IPuzCellCoord      coord)

2249

2250

240

 GArray *clues = NULL;

2251

2252

240

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), NULL);

2253

2254

240

  clues = ipuz_crossword_get_clues (self, direction);

2255

240

  if (clues == NULL)

2256

8

    return NULL;

2257

2258

2178

  for (guint i = 0; i < clues->len; i ++)

2259

2260

      IPuzClue *clue;

2261

2037

      clue = g_array_index (clues, IPuzClue *, i);

2262

2037

      if (ipuz_clue_contains_cell (clue, coord))

2263

91

        return clue;

2264

2265

141

  return NULL;

2266

2267

2268

static gboolean

2269

ipuz_crossword_game_won_solution (IPuzCrossword *self)

2270

2271

  IPuzCrosswordPrivate *priv;

2272

  guint row, col;

2273

2274

  priv = ipuz_crossword_get_instance_private (self);

2275

2276

  for (row = 0; row < (guint) priv->height; row++)

2277

2278

      for (col = 0; col < (guint) priv->width; col++)

2279

2280

          IPuzCell *cell;

2281

          IPuzCellCoord coord = { .row = row, .column = col };

2282

2283

          cell = ipuz_crossword_get_cell (self, coord);

2284

          if (IPUZ_CELL_IS_GUESSABLE (cell))

2285

2286

              const char *guess = ipuz_guesses_get_guess (priv->guesses, coord);

2287

              /* FIXME(charset): There are puzzles where the solution charset

2288

               * doesn't match the solution and we have a bunch of

2289

               * blank solution values. We want to catch that case.

2290

*/

2291

              /* FIXME(charset): should we normalize guess and solution first?*/

2292

              if (guess == NULL)

2293

                return FALSE;

2294

              if (g_strcmp0 (guess, cell->solution))

2295

                return FALSE;

2296

2297

2298

2299

2300

  return TRUE;

2301

2302

2303

gboolean

2304

ipuz_crossword_game_won (IPuzCrossword *self)

2305

2306

  guint flags;

2307

2308

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), FALSE);

2309

2310

  /* You can't win without playing! */

2311

  if (ipuz_crossword_get_guesses (self) == NULL)

2312

    return FALSE;

2313

2314

  flags = ipuz_puzzle_get_flags (IPUZ_PUZZLE (self));

2315

2316

  if (flags & IPUZ_PUZZLE_FLAG_HAS_SOLUTION)

2317

    return ipuz_crossword_game_won_solution (self);

2318

2319

  if (flags & IPUZ_PUZZLE_FLAG_HAS_CHECKSUM)

2320

2321

      /* FIXME(checksum): need to support this! */

2322

2323

  return FALSE;

2324

2325

2326

2327

static void

2328

solution_chars_foreach_cb (IPuzCrossword *crossword,

2329

                           IPuzCell      *cell,

2330

                           IPuzCellCoord  coord,

2331

                           gpointer       user_data)

2332

2333

  IPuzCharsetBuilder *builder = user_data;

2334

2335

  ipuz_charset_builder_add_text (builder, ipuz_cell_get_solution (cell));

2336

2337

2338

IPuzCharset *

2339

ipuz_crossword_get_solution_chars (IPuzCrossword *self)

2340

2341

  IPuzCharsetBuilder *builder;

2342

2343

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), NULL);

2344

2345

  builder = ipuz_charset_builder_new ();

2346

  ipuz_crossword_foreach_cell (self, solution_chars_foreach_cb, builder);

2347

2348

  return ipuz_charset_builder_build (builder);

2349

2350

2351

static IPuzClue *

2352

240

calculate_clue (IPuzCrossword     *self,

2353

                IPuzClueDirection  direction,

2354

                IPuzCellCoord      coord,

2355

                gint               number)

2356

2357

  IPuzClue *clue;

2358

  IPuzCell *cell;

2359

240

  gboolean valid = FALSE;

2360

240

  guint len = 0;

2361

2362

  /* If we're already in a clue, we don't want to create another one */

2363

240

  if (ipuz_crossword_find_clue_by_coord (self, direction, coord) != NULL)

2364

91

    return NULL;

2365

2366

  /* create a perspective new clue, and see if it's valid. We do this

2367

   * by seeing if we can walk in direction and append the cell to the

2368

   * clue. If our len is > 1, then it means that it's a valid

2369

   * clue. Also, we do a dance between NORMAL cells and GESSABLE cells

2370

   * because we can have a row of all guessable cells that shouldn't

2371

   * be calculated. See the first puzzle as an example of this. */

2372

149

  clue = ipuz_clue_new ();

2373

149

  ipuz_clue_set_direction (clue, direction);

2374

149

  ipuz_clue_set_number (clue, number);

2375

2376

149

  cell = ipuz_crossword_get_cell (self, coord);

2377

736

  while (IPUZ_CELL_IS_NORMAL (cell))

2378

2379

736

      ipuz_clue_append_cell (clue, coord);

2380

736

      len ++;

2381

736

      if (IPUZ_CELL_IS_GUESSABLE (cell))

2382

729

        valid = TRUE;

2383

2384

1109

      if (direction == IPUZ_CLUE_DIRECTION_ACROSS &&

2385

373

          !ipuz_crossword_clue_continues_right (self, coord))

2386

76

        break;

2387

2388

1023

      if (direction == IPUZ_CLUE_DIRECTION_DOWN &&

2389

363

          !ipuz_crossword_clue_continues_down (self, coord))

2390

73

        break;

2391

2392

587

      if (direction == IPUZ_CLUE_DIRECTION_ACROSS)

2393

297

        coord.column ++;

2394

      else

2395

290

        coord.row ++;

2396

587

      cell = ipuz_crossword_get_cell (self, coord);

2397

2398

2399

149

  if (valid && len > 1)

2400

127

    return clue;

2401

2402

22

  ipuz_clue_free (clue);

2403

22

  return NULL;

2404

2405

2406

/**

2407

 * ipuz_crossword_get_symmetry:

2408

 * @self: A `IPuzCrossword`

2409

2410

 * Calculates the symmetry of @self. Note, there can be multiple valid

2411

 * calculations for a board. For example, we can't say anything at all

2412

 * about the symmetry for a blank, square board. This function returns

2413

 * the first one that matches.

2414

2415

 * Returns: The apparent symmetry of the puzzle.

2416

**/

2417

IPuzSymmetry

2418

2

ipuz_crossword_get_symmetry (IPuzCrossword *self)

2419

2420

  IPuzCrosswordPrivate *priv;

2421

  guint row, col;

2422

  /* We assume these are true until proved otherwise */

2423

2

  gboolean is_half_rotational = TRUE;

2424

2

  gboolean is_quarter_rotational = TRUE;

2425

2

  gboolean is_horizontal = TRUE;

2426

2

  gboolean is_vertical = TRUE;

2427

2

  gboolean is_mirrored = TRUE;

2428

2429

2

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), IPUZ_SYMMETRY_NONE);

2430

2431

2

  priv = ipuz_crossword_get_instance_private (self);

2432

2433

  /* Quarter-symmetric only makes sense if we're square */

2434

2

  if (priv->width != priv->height)

2435

    is_quarter_rotational = FALSE;

2436

2437

14

  for (row = 0; row < (guint) priv->height; row++)

2438

2439

159

      for (col = 0; col < (guint) priv->width; col++)

2440

2441

147

          IPuzCellCoord coord = { .row = row, .column = col };

2442

          IPuzCellCoord mirror_coord;

2443

2444

147

          if (is_half_rotational)

2445

2446

147

              mirror_coord = ipuz_symmetry_calculate (coord, priv->width, priv->height, IPUZ_SYMMETRY_ROTATIONAL_HALF, IPUZ_SYMMETRY_OFFSET_OPPOSITE);

2447

147

              if (! ipuz_crossword_check_mirror (self, coord, mirror_coord, IPUZ_SYMMETRY_ROTATIONAL_HALF, IPUZ_SYMMETRY_OFFSET_OPPOSITE))

2448

2449

1

                  is_half_rotational = FALSE;

2450

1

                  is_quarter_rotational = FALSE;

2451

2452

2453

2454

147

          if (is_quarter_rotational)

2455

2456

146

              mirror_coord = ipuz_symmetry_calculate (coord, priv->width, priv->height, IPUZ_SYMMETRY_ROTATIONAL_QUARTER, IPUZ_SYMMETRY_OFFSET_CW_ADJACENT);

2457

146

              if (! ipuz_crossword_check_mirror (self, coord, mirror_coord, IPUZ_SYMMETRY_ROTATIONAL_QUARTER, IPUZ_SYMMETRY_OFFSET_CW_ADJACENT))

2458

                is_quarter_rotational = FALSE;

2459

2460

146

              mirror_coord = ipuz_symmetry_calculate (coord, priv->width, priv->height, IPUZ_SYMMETRY_ROTATIONAL_QUARTER, IPUZ_SYMMETRY_OFFSET_CCW_ADJACENT);

2461

146

              if (! ipuz_crossword_check_mirror (self, coord, mirror_coord, IPUZ_SYMMETRY_ROTATIONAL_QUARTER, IPUZ_SYMMETRY_OFFSET_CCW_ADJACENT))

2462

                is_quarter_rotational = FALSE;

2463

2464

2465

147

          if (is_horizontal)

2466

2467

4

              mirror_coord = ipuz_symmetry_calculate (coord, priv->width, priv->height, IPUZ_SYMMETRY_HORIZONTAL, IPUZ_SYMMETRY_OFFSET_OPPOSITE);

2468

4

              if (! ipuz_crossword_check_mirror (self, coord, mirror_coord, IPUZ_SYMMETRY_HORIZONTAL, IPUZ_SYMMETRY_OFFSET_OPPOSITE))

2469

2470

2

                  is_horizontal = FALSE;

2471

2

                  is_mirrored = FALSE;

2472

2473

2474

2475

147

          if (is_vertical)

2476

2477

4

              mirror_coord = ipuz_symmetry_calculate (coord, priv->width, priv->height, IPUZ_SYMMETRY_VERTICAL, IPUZ_SYMMETRY_OFFSET_OPPOSITE);

2478

4

              if (! ipuz_crossword_check_mirror (self, coord, mirror_coord, IPUZ_SYMMETRY_VERTICAL, IPUZ_SYMMETRY_OFFSET_OPPOSITE))

2479

2480

2

                  is_vertical = FALSE;

2481

2

                  is_mirrored = FALSE;

2482

2483

2484

2485

147

          if (is_mirrored)

2486

2487

2

              mirror_coord = ipuz_symmetry_calculate (coord, priv->width, priv->height, IPUZ_SYMMETRY_MIRRORED, IPUZ_SYMMETRY_OFFSET_CW_ADJACENT);

2488

2

              if (! ipuz_crossword_check_mirror (self, coord, mirror_coord, IPUZ_SYMMETRY_MIRRORED, IPUZ_SYMMETRY_OFFSET_CW_ADJACENT))

2489

                is_mirrored = FALSE;

2490

2491

2

              mirror_coord = ipuz_symmetry_calculate (coord, priv->width, priv->height, IPUZ_SYMMETRY_MIRRORED, IPUZ_SYMMETRY_OFFSET_CCW_ADJACENT);

2492

2

              if (! ipuz_crossword_check_mirror (self, coord, mirror_coord, IPUZ_SYMMETRY_MIRRORED, IPUZ_SYMMETRY_OFFSET_CCW_ADJACENT))

2493

                is_mirrored = FALSE;

2494

2495

2496

          /* We've eliminated everything */

2497

147

          if (! is_half_rotational &&

2498

1

              ! is_quarter_rotational &&

2499

1

              ! is_horizontal &&

2500

1

              ! is_vertical &&

2501

              ! is_mirrored)

2502

2503

1

              return IPUZ_SYMMETRY_NONE;

2504

2505

2506

2507

2508

1

  if (is_quarter_rotational)

2509

1

    return IPUZ_SYMMETRY_ROTATIONAL_QUARTER;

2510

  else if (is_half_rotational)

2511

    return IPUZ_SYMMETRY_ROTATIONAL_HALF;

2512

  else if (is_mirrored)

2513

    return IPUZ_SYMMETRY_MIRRORED;

2514

  else if (is_horizontal)

2515

    return IPUZ_SYMMETRY_HORIZONTAL;

2516

  else if (is_vertical)

2517

    return IPUZ_SYMMETRY_VERTICAL;

2518

  else

2519

    g_assert_not_reached ();

2520

2521

2522

static void

2523

8

print_clues (GArray   *clues,

2524

             gboolean  showenumerations)

2525

2526

  guint i;

2527

2528

108

  for (i = 0; i < clues->len; i++)

2529

2530

100

      IPuzClue *clue = g_array_index (clues, IPuzClue *, i);

2531

100

      g_autoptr (IPuzEnumeration) enumeration = NULL;

2532

2533

100

      enumeration = ipuz_clue_get_enumeration (clue);

2534

100

      g_print ("\t");

2535

100

      if (ipuz_clue_get_number (clue) > 0)

2536

43

        g_print ("%d. ", ipuz_clue_get_number (clue));

2537

57

      else if (ipuz_clue_get_label (clue))

2538

57

        g_print ("%s. ", ipuz_clue_get_label (clue));

2539

100

      if (ipuz_clue_get_clue_text (clue))

2540

90

        g_print ("%s ", ipuz_clue_get_clue_text (clue));

2541

100

      if (showenumerations && enumeration)

2542

2543

68

          g_autofree gchar *display = ipuz_enumeration_get_display (enumeration);

2544

34

          g_print ("(%s)", display);

2545

2546

100

      g_print ("\n");

2547

2548

100

      if (clue->cells->len > 0)

2549

2550

100

          g_print ("\tcells: ");

2551

711

          for (guint j = 0; j < clue->cells->len; j++)

2552

2553

611

              IPuzCellCoord *coord = & (g_array_index (clue->cells, IPuzCellCoord, j));

2554

611

              g_print ("[%u, %u] ", coord->row, coord->column);

2555

2556

100

          g_print ("\n");

2557

2558

2559

8

2560

2561

/* Correction API */

2562

2563

void

2564

3

ipuz_crossword_fix_symmetry (IPuzCrossword *self,

2565

                             IPuzSymmetry   symmetry,

2566

                             GArray        *coords)

2567

2568

  IPuzCrosswordClass *klass;

2569

2570

3

  g_return_if_fail (IPUZ_IS_CROSSWORD (self));

2571

3

  g_return_if_fail (coords != NULL);

2572

2573

3

  klass = IPUZ_CROSSWORD_GET_CLASS (self);

2574

2575

3

  return klass->fix_symmetry (self, symmetry, coords);

2576

2577

2578

void

2579

5

ipuz_crossword_fix_numbering (IPuzCrossword *self)

2580

2581

  IPuzCrosswordClass *klass;

2582

2583

5

  g_return_if_fail (IPUZ_IS_CROSSWORD (self));

2584

2585

5

  klass = IPUZ_CROSSWORD_GET_CLASS (self);

2586

2587

5

  return klass->fix_numbering (self);

2588

2589

2590

void

2591

4

ipuz_crossword_fix_clues (IPuzCrossword *self)

2592

2593

  IPuzCrosswordClass *klass;

2594

2595

4

  g_return_if_fail (IPUZ_IS_CROSSWORD (self));

2596

2597

4

  klass = IPUZ_CROSSWORD_GET_CLASS (self);

2598

2599

4

  return klass->fix_clues (self);

2600

2601

2602

void

2603

3

ipuz_crossword_fix_enumerations (IPuzCrossword *self)

2604

2605

  IPuzCrosswordClass *klass;

2606

2607

3

  g_return_if_fail (IPUZ_IS_CROSSWORD (self));

2608

2609

3

  klass = IPUZ_CROSSWORD_GET_CLASS (self);

2610

2611

3

  return klass->fix_enumerations (self);

2612

2613

2614

void

2615

7

ipuz_crossword_fix_styles (IPuzCrossword *self)

2616

2617

  IPuzCrosswordClass *klass;

2618

2619

7

  g_return_if_fail (IPUZ_IS_CROSSWORD (self));

2620

2621

7

  klass = IPUZ_CROSSWORD_GET_CLASS (self);

2622

2623

7

  return klass->fix_styles (self);

2624

2625

2626

void

2627

6

ipuz_crossword_fix_all (IPuzCrossword *self,

2628

                        const char    *first_attribute_name,

2629

                        ...)

2630

2631

  IPuzCrosswordClass *klass;

2632

  va_list var_args;

2633

2634

6

  g_return_if_fail (IPUZ_IS_CROSSWORD (self));

2635

2636

6

  klass = IPUZ_CROSSWORD_GET_CLASS (self);

2637

2638

6

  va_start (var_args, first_attribute_name);

2639

6

  klass->fix_all (self, first_attribute_name, var_args);

2640

6

  va_end (var_args);

2641

2642

2643

gboolean

2644

638

ipuz_crossword_clue_continues_up (IPuzCrossword *self,

2645

                                  IPuzCellCoord  coord)

2646

2647

  IPuzCrosswordClass *klass;

2648

2649

638

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), FALSE);

2650

2651

638

  klass = IPUZ_CROSSWORD_GET_CLASS (self);

2652

2653

638

  return klass->clue_continues_up (self, coord);

2654

2655

2656

gboolean

2657

618

ipuz_crossword_clue_continues_down (IPuzCrossword *self,

2658

                                    IPuzCellCoord  coord)

2659

2660

  IPuzCrosswordClass *klass;

2661

2662

618

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), FALSE);

2663

2664

618

  klass = IPUZ_CROSSWORD_GET_CLASS (self);

2665

2666

618

  return klass->clue_continues_down (self, coord);

2667

2668

2669

gboolean

2670

558

ipuz_crossword_clue_continues_left (IPuzCrossword *self,

2671

                                    IPuzCellCoord  coord)

2672

2673

  IPuzCrosswordClass *klass;

2674

2675

558

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), FALSE);

2676

2677

558

  klass = IPUZ_CROSSWORD_GET_CLASS (self);

2678

2679

558

  return klass->clue_continues_left (self, coord);

2680

2681

2682

gboolean

2683

594

ipuz_crossword_clue_continues_right (IPuzCrossword *self,

2684

                                     IPuzCellCoord  coord)

2685

2686

  IPuzCrosswordClass *klass;

2687

2688

594

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), FALSE);

2689

2690

594

  klass = IPUZ_CROSSWORD_GET_CLASS (self);

2691

2692

594

  return klass->clue_continues_right (self, coord);

2693

2694

2695

void

2696

17

ipuz_crossword_mirror_cell (IPuzCrossword      *self,

2697

                            IPuzCellCoord       src_coord,

2698

                            IPuzCellCoord       dest_coord,

2699

                            IPuzSymmetry        symmetry,

2700

                            IPuzSymmetryOffset  symmetry_offset)

2701

2702

  IPuzCrosswordClass *klass;

2703

2704

17

  g_return_if_fail (IPUZ_IS_CROSSWORD (self));

2705

2706

17

  klass = IPUZ_CROSSWORD_GET_CLASS (self);

2707

2708

17

  klass->mirror_cell (self, src_coord, dest_coord, symmetry, symmetry_offset);

2709

2710

2711

gboolean

2712

451

ipuz_crossword_check_mirror (IPuzCrossword      *self,

2713

                             IPuzCellCoord       src_coord,

2714

                             IPuzCellCoord       target_coord,

2715

                             IPuzSymmetry        symmetry,

2716

                             IPuzSymmetryOffset  symmetry_offset)

2717

2718

  IPuzCrosswordClass *klass;

2719

2720

451

  g_return_val_if_fail (IPUZ_IS_CROSSWORD (self), FALSE);

2721

2722

451

  klass = IPUZ_CROSSWORD_GET_CLASS (self);

2723

2724

451

  return klass->check_mirror (self, src_coord, target_coord, symmetry, symmetry_offset);

2725

2726

2727

/* Public Functions */

2728

2729

void

2730

4

ipuz_crossword_print (IPuzCrossword *self)

2731

2732

4

  g_return_if_fail (IPUZ_CROSSWORD (self));

2733

2734

  /* Puzzle */

2735

4

  g_autofree gchar *copyright = NULL;

2736

4

  g_autofree gchar *publisher = NULL;

2737

4

  g_autofree gchar *publication = NULL;

2738

4

  g_autofree gchar *url = NULL;

2739

4

  g_autofree gchar *uniquieid = NULL;

2740

4

  g_autofree gchar *title = NULL;

2741

4

  g_autofree gchar *intro = NULL;

2742

4

  g_autofree gchar *explanation = NULL;

2743

4

  g_autofree gchar *annotation = NULL;

2744

4

  g_autofree gchar *author = NULL;

2745

4

  g_autofree gchar *editor = NULL;

2746

4

  g_autofree gchar *date = NULL;

2747

4

  g_autofree gchar *notes = NULL;

2748

4

  g_autofree gchar *difficulty = NULL;

2749

4

  g_autofree gchar *charset_str = NULL;

2750

4

  g_autofree gchar *origin = NULL;

2751

4

  g_autofree gchar *block = NULL;

2752

4

  g_autofree gchar *empty = NULL;

2753

2754

  /* Crossword */

2755

  gint width;

2756

  gint height;

2757

  gboolean showenumerations;

2758

  IPuzCluePlacement clue_placement;

2759

  IPuzBoard *board;

2760

  IPuzCrosswordPrivate *priv;

2761

2762

4

  char ESC=27;

2763

2764

4

  g_object_get (G_OBJECT (self),

2765

                "title", &title,

2766

                "copyright", &copyright,

2767

                "publisher", &publisher,

2768

                "publication", &publication,

2769

                "url", &url,

2770

                "uniqueid", &uniquieid,

2771

                "intro", &intro,

2772

                "explanation", &explanation,

2773

                "annotation", &annotation,

2774

                "author", &author,

2775

                "editor", &editor,

2776

                "date", &date,

2777

                "notes", &notes,

2778

                "difficulty", &difficulty,

2779

                "charset-str", &charset_str,

2780

                "origin", &origin,

2781

                "block", &block,

2782

                "empty", &empty,

2783

                "showenumerations", &showenumerations,

2784

                "clue-placement", &clue_placement,

2785

                "width", &width,

2786

                "height", &height,

2787

                "board", &board,

2788

                NULL);

2789

4

  priv = ipuz_crossword_get_instance_private (self);

2790

2791

4

  g_print ("\n");

2792

  /* Print the title section */

2793

4

  g_print ("%c[1mTitle: %s%c[0m\n", ESC, title?title:"(null)", ESC);

2794

2795

  /* Print the type */

2796

4

  if (IPUZ_IS_ACROSTIC (self))

2797

1

    g_print ("\tType: Acrostic Puzzle\n");

2798

3

  else if (IPUZ_IS_ARROWWORD (self))

2799

    g_print ("\tType: Arrowword Puzzle\n");

2800

3

  else if (IPUZ_IS_BARRED (self))

2801

    g_print ("\tType: Barred Puzzle\n");

2802

3

  else if (IPUZ_IS_CRYPTIC (self))

2803

1

    g_print ("\tType: Cryptic Crossword Puzzle\n");

2804

2

  else if (IPUZ_IS_FILIPPINE (self))

2805

    g_print ("\tType: Filippine Puzzle\n");

2806

  else /* Default */

2807

2

    g_print ("\tType: Crossword Puzzle\n");

2808

2809

2810

4

  if (author || editor)

2811

2812

3

      if (author) g_print ("\tby %s\t", author);

2813

3

      if (editor) g_print ("\tedited by %s", editor);

2814

3

      g_print ("\n");

2815

2816

4

  if (copyright) g_print ("\tCopyright: %s\n", copyright);

2817

4

  if (title || author || editor || copyright || date) g_print ("\n");

2818

2819

59

  for (int i = 0; i < width + 1; i++)

2820

55

    g_print ("██");

2821

4

  g_print ("\n");

2822

49

  for (int row = 0; row < height; row ++)

2823

2824

45

      g_print ("█");

2825

728

      for (int column = 0; column < width; column ++)

2826

2827

683

          IPuzCellCoord coord = { .row = row, .column = column };

2828

683

          IPuzCell *cell = ipuz_board_get_cell (board, coord);

2829

          gint n;

2830

683

          switch (ipuz_cell_get_cell_type (cell))

2831

2832

115

            case IPUZ_CELL_BLOCK:

2833

115

              g_print ("▓▓");

2834

115

              break;

2835

98

            case IPUZ_CELL_NULL:

2836

98

              g_print ("▞▚");

2837

98

              break;

2838

470

            case IPUZ_CELL_NORMAL:

2839

470

              n = ipuz_cell_get_number (cell);

2840

470

              if (n == 0)

2841

425

                g_print ("  ");

2842

              else

2843

45

                g_print ((n<10?"%d ":"%d"),n);

2844

470

              break;

2845

2846

2847

45

      g_print ("█\n█");

2848

728

      for (int column = 0; column < width; column ++)

2849

2850

683

          const gchar *solution = NULL;

2851

683

          IPuzCellCoord coord = { .row = row, .column = column };

2852

683

          IPuzCell *cell = ipuz_board_get_cell (board, coord);

2853

683

          switch (ipuz_cell_get_cell_type (cell))

2854

2855

115

            case IPUZ_CELL_BLOCK:

2856

115

              g_print ("▓▓");

2857

115

              break;

2858

98

            case IPUZ_CELL_NULL:

2859

98

              g_print ("▚▞");

2860

98

              break;

2861

470

            case IPUZ_CELL_NORMAL:

2862

470

               solution = ipuz_cell_get_solution (cell);

2863

470

              if (solution)

2864

468

                g_print (" %s", solution);

2865

              else

2866

2

                g_print ("  ");

2867

470

              break;

2868

2869

2870

45

      g_print ("█\n");

2871

2872

59

  for (int column = 0; column < width + 1; column++)

2873

55

    g_print ("██");

2874

4

  g_print ("\n\n");

2875

2876

  GArray *clues;

2877

4

  if (ipuz_crossword_get_n_clue_sets (self) > 0)

2878

4

    g_print ("%c[1mClues%c[0m\n", ESC, ESC);

2879

12

  for (guint i = 0; i < ipuz_crossword_get_n_clue_sets (self); i++)

2880

2881

      IPuzClueDirection direction;

2882

      IPuzClueDirection orig_direction;

2883

2884

8

      direction = ipuz_crossword_clue_set_get_dir (self, i);

2885

8

      orig_direction = ipuz_clue_sets_get_original_direction (priv->clue_sets, direction);

2886

8

      clues = ipuz_crossword_get_clues (self, direction);

2887

8

      g_print ("\t%s:", ipuz_clue_direction_to_string (orig_direction));

2888

8

      if (orig_direction != direction)

2889

2

        g_print ("%s\n", ipuz_clue_sets_get_label (priv->clue_sets, direction));

2890

      else

2891

6

        g_print ("\n");

2892

8

      print_clues (clues, showenumerations);

2893

8

      g_print ("\n");

2894

2895

4

  if (ipuz_crossword_get_n_clue_sets (self) > 0)

2896

4

    g_print ("\n");

2897

2898

4

  g_print ("%c[1mDocument Information%c[0m\n", ESC, ESC);

2899

4

  if (date) g_print ("\tDate: %s\n", date);

2900

4

  if (publisher) g_print ("\tPublisher: %s\n", publisher);

2901

4

  if (publication) g_print ("\tPublication: %s\n", publication);

2902

4

  if (url) g_print ("\tURL: %s\n:", url);

2903

4

  if (uniquieid) g_print ("\tUnique ID:%s\n", uniquieid);

2904

4

  if (difficulty) g_print ("\tDifficulty:%s\n", difficulty);

2905

2906

4

  g_print ("\n");

2907

2908

4

  g_print ("%c[1mDisplay Information%c[0m\n", ESC, ESC);

2909

4

  if (block) g_print ("\tBlock string: '%s'\n", block);

2910

4

  if (empty) g_print ("\tEmpty cell string: '%s'\n", empty);

2911

4

  if (charset_str) g_print ("\tValid charset-str: '%s'\n", charset_str);

2912

4

  g_print ("\tShow enumerations: %s\n", showenumerations?"true":"false");

2913

2914

4

  switch (clue_placement)

2915

2916

4

    case IPUZ_CLUE_PLACEMENT_NULL:

2917

4

      g_print ("\tClue placement: null\n");

2918

4

      break;

2919

    case IPUZ_CLUE_PLACEMENT_BEFORE:

2920

      g_print ("\tClue placement: before\n");

2921

      break;

2922

    case IPUZ_CLUE_PLACEMENT_AFTER:

2923

      g_print ("\tClue placement: after\n");

2924

      break;

2925

    case IPUZ_CLUE_PLACEMENT_BLOCKS:

2926

      g_print ("\tClue placement: blocks\n");

2927

      break;

2928

2929

4

  g_print ("\n");

2930

#if 0

2931

  "intro", &intro,

2932

  "explanation", &explanation,

2933

  "annotation", &annotation,

2934

  "origin", &origin,

2935

#endif

2936

2937

4

  g_object_unref (board);

2938