~mc.../inkscape/inkscape

snprintf(line, sizeof(line), " in chunk %d (x=%f, baselineshift=%f)\n", _spans[span_index].in_chunk, _chunks[_spans[span_index].in_chunk].left_x, _spans[span_index].baseline_shift);

244

result += line;

245

if (_spans[span_index].font) {

246

snprintf(line, sizeof(line), " font '%s' %f %s %s\n", pango_font_description_get_family(_spans[span_index].font->descr), _spans[span_index].font_size, style_to_text(pango_font_description_get_style(_spans[span_index].font->descr)), weight_to_text(pango_font_description_get_weight(_spans[span_index].font->descr)));

247

result += line;

248

}

249

snprintf(line, sizeof(line), " x_start = %f, x_end = %f\n", _spans[span_index].x_start, _spans[span_index].x_end);

250

result += line;

251

snprintf(line, sizeof(line), " line height: ascent %f, descent %f leading %f\n", _spans[span_index].line_height.ascent, _spans[span_index].line_height.descent, _spans[span_index].line_height.leading);

252

result += line;

253

snprintf(line, sizeof(line), " direction %s, block-progression %s\n", direction_to_text(_spans[span_index].direction), direction_to_text(_spans[span_index].block_progression));

254

result += line;

255

result += " ** characters:\n";

256

Glib::ustring::const_iterator iter_char = _spans[span_index].input_stream_first_character;

257

// very inefficent code. what the hell, it's only debug stuff.

258

for (unsigned char_index = 0 ; char_index < _characters.size() ; char_index++) {

259

if (_characters[char_index].in_span != span_index) continue;

260

if (_input_stream[_spans[span_index].in_input_stream_item]->Type() != TEXT_SOURCE) {

261

snprintf(line, sizeof(line), " %d: control x=%f flags=%03x glyph=%d\n", char_index, _characters[char_index].x, *(unsigned*)&_characters[char_index].char_attributes, _characters[char_index].in_glyph);

262

} else {

263

snprintf(line, sizeof(line), " %d: '%c' x=%f flags=%03x glyph=%d\n", char_index, *iter_char, _characters[char_index].x, *(unsigned*)&_characters[char_index].char_attributes, _characters[char_index].in_glyph);

264

iter_char++;

265

}

266

result += line;

267

}

268

result += " ** glyphs:\n";

269

for (unsigned glyph_index = 0 ; glyph_index < _glyphs.size() ; glyph_index++) {

270

if (_characters[_glyphs[glyph_index].in_character].in_span != span_index) continue;

271

snprintf(line, sizeof(line), " %d: %d (%f,%f) rot=%f cx=%f char=%d\n", glyph_index, _glyphs[glyph_index].glyph, _glyphs[glyph_index].x, _glyphs[glyph_index].y, _glyphs[glyph_index].rotation, _glyphs[glyph_index].width, _glyphs[glyph_index].in_character);

272

result += line;

273

}

274

result += "\n";

275

}

276

result += "EOT\n";

277

return result;

278

}

279

280

void Layout::fitToPathAlign(SVGLength const &startOffset, Path const &path)

281

{

282

double offset = 0.0;

283

284

if (startOffset._set) {

285

if (startOffset.unit == SVGLength::PERCENT)

286

offset = startOffset.computed * const_cast<Path&>(path).Length();

287

else

288

offset = startOffset.computed;

289

}

290

291

switch (_paragraphs.front().alignment) {

292

case CENTER:

293

offset -= _getChunkWidth(0) * 0.5;

294

break;

295

case RIGHT:

296

offset -= _getChunkWidth(0);

297

break;

298

default:

299

break;

300

}

301

302

if (_characters.empty()) {

303

int unused = 0;

304

Path::cut_position *point_otp = const_cast<Path&>(path).CurvilignToPosition(1, &offset, unused);

305

if (offset >= 0.0 && point_otp != NULL && point_otp[0].piece >= 0) {

306

NR::Point point;

307

NR::Point tangent;

308

const_cast<Path&>(path).PointAndTangentAt(point_otp[0].piece, point_otp[0].t, point, tangent);

309

_empty_cursor_shape.position = point;

310

_empty_cursor_shape.rotation = atan2(tangent[NR::Y], tangent[NR::X]);

311

}

312

}

313

314

for (unsigned char_index = 0 ; char_index < _characters.size() ; ) {

315

int next_cluster_glyph_index;

316

unsigned next_cluster_char_index;

317

double character_advance;

318

Span const &span = _characters[char_index].span(this);

319

320

for (next_cluster_char_index = char_index + 1 ;

321

next_cluster_char_index < _characters.size() && !_characters[next_cluster_char_index].char_attributes.is_cursor_position;

322

next_cluster_char_index++);

323

324

if (next_cluster_char_index == _characters.size()) {

325

next_cluster_glyph_index = _glyphs.size();

326

character_advance = 0.0; // arbitrary because we're not going to advance

327

} else {

328

next_cluster_glyph_index = _characters[next_cluster_char_index].in_glyph;

329

character_advance = (_glyphs[next_cluster_glyph_index].x + _glyphs[next_cluster_glyph_index].chunk(this).left_x)

330

- (_glyphs[_characters[char_index].in_glyph].x + span.chunk(this).left_x);

331

}

332

333

double start_offset = offset + span.x_start + _characters[char_index].x;

334

double cluster_width = 0.0;

335

for (int glyph_index = _characters[char_index].in_glyph ; glyph_index < next_cluster_glyph_index ; glyph_index++)

336

cluster_width += _glyphs[glyph_index].width;

337

if (span.direction == RIGHT_TO_LEFT)

338

start_offset -= cluster_width;

339

double end_offset = start_offset + cluster_width;

340

341

int unused = 0;

342

double midpoint_offset = (start_offset + end_offset) * 0.5;

343

// as far as I know these functions are const, they're just not marked as such

344

Path::cut_position *midpoint_otp = const_cast<Path&>(path).CurvilignToPosition(1, &midpoint_offset, unused);

345

if (midpoint_offset >= 0.0 && midpoint_otp != NULL && midpoint_otp[0].piece >= 0) {

346

NR::Point midpoint;

347

NR::Point tangent;

348

349

const_cast<Path&>(path).PointAndTangentAt(midpoint_otp[0].piece, midpoint_otp[0].t, midpoint, tangent);

350

351

if (start_offset >= 0.0 && end_offset >= 0.0) {

352

Path::cut_position *start_otp = const_cast<Path&>(path).CurvilignToPosition(1, &start_offset, unused);

353

if (start_otp != NULL && start_otp[0].piece >= 0) {

354

Path::cut_position *end_otp = const_cast<Path&>(path).CurvilignToPosition(1, &end_offset, unused);

355

if (end_otp != NULL && end_otp[0].piece >= 0) {

356

bool on_same_subpath = true;

357

for (size_t i = 0 ; i < path.pts.size() ; i++) {

358

if (path.pts[i].piece <= start_otp[0].piece) continue;

359

if (path.pts[i].piece >= end_otp[0].piece) break;

360

if (path.pts[i].isMoveTo == polyline_moveto) {

361

on_same_subpath = false;

362

break;

363

}

364

}

365

if (on_same_subpath) {

366

// both points were on the same subpath (without this test the angle is very weird)

367

NR::Point startpoint, endpoint;

368

const_cast<Path&>(path).PointAt(start_otp[0].piece, start_otp[0].t, startpoint);

369

const_cast<Path&>(path).PointAt(end_otp[0].piece, end_otp[0].t, endpoint);

370

if (endpoint != startpoint) {

371

tangent = endpoint - startpoint;

372

tangent.normalize();

373

} else {

374

tangent = NR::Point (0,0);

375

}

376

}

377

g_free(end_otp);

378

}

379

g_free(start_otp);

380

}

381

}

382

383

double rotation = atan2(tangent[1], tangent[0]);

384

for (int glyph_index = _characters[char_index].in_glyph ; glyph_index < next_cluster_glyph_index ; glyph_index++) {

385

double tangent_shift = -cluster_width * 0.5 + _glyphs[glyph_index].x - (_characters[char_index].x + span.x_start);

386

double normal_shift = _glyphs[glyph_index].y;

387

if (span.direction == RIGHT_TO_LEFT)

388

tangent_shift += cluster_width;

389

_glyphs[glyph_index].x = midpoint[0] - span.chunk(this).left_x + tangent[0] * tangent_shift - tangent[1] * normal_shift;

390

_glyphs[glyph_index].y = midpoint[1] - _lines.front().baseline_y + tangent[1] * tangent_shift + tangent[0] * normal_shift;

391

_glyphs[glyph_index].rotation += rotation;

392

}

393

} else { // outside the bounds of the path: hide the glyphs

394

_characters[char_index].in_glyph = -1;

395

}

396

g_free(midpoint_otp);

397

398

char_index = next_cluster_char_index;

399

}

400

401

for (unsigned span_index = 0 ; span_index < _spans.size() ; span_index++) {

402

_spans[span_index].x_start += offset;

403

_spans[span_index].x_end += offset;

404

}

405

406

_path_fitted = &path;

407

}

408

409

SPCurve *Layout::convertToCurves(iterator const &from_glyph, iterator const &to_glyph) const

410

{

411

GSList *cc = NULL;

412

413

for (int glyph_index = from_glyph._glyph_index ; glyph_index < to_glyph._glyph_index ; glyph_index++) {

414

NRMatrix glyph_matrix;

415

Span const &span = _glyphs[glyph_index].span(this);

416

_getGlyphTransformMatrix(glyph_index, &glyph_matrix);

417

418

NRBPath bpath;

419

bpath.path = (NArtBpath*)span.font->ArtBPath(_glyphs[glyph_index].glyph);

420

if (bpath.path) {

421

NArtBpath *abp = nr_artpath_affine(bpath.path, glyph_matrix);

422

SPCurve *c = sp_curve_new_from_bpath(abp);

423

if (c) cc = g_slist_prepend(cc, c);

424

}

425

}

426

cc = g_slist_reverse(cc);

427

428

SPCurve *curve;

429

if ( cc ) {

430

curve = sp_curve_concat(cc);

431

} else {

432

curve = sp_curve_new();

433

}

434

435

while (cc) {

436

/* fixme: This is dangerous, as we are mixing art_alloc and g_new */

437

sp_curve_unref((SPCurve *) cc->data);

438

cc = g_slist_remove(cc, cc->data);

439

}

440

441

return curve;

442

}

443

444

void Layout::transform(NR::Matrix const &transform)

445

{

446

// this is all massively oversimplified

447

// I can't actually think of anybody who'll want to use it at the moment, so it'll stay simple

448

for (unsigned glyph_index = 0 ; glyph_index < _glyphs.size() ; glyph_index++) {

449

NR::Point point(_glyphs[glyph_index].x, _glyphs[glyph_index].y);

450

point *= transform;

451

_glyphs[glyph_index].x = point[0];

452

_glyphs[glyph_index].y = point[1];

453

}

454

}

455

456

}//namespace Text

457

}//namespace Inkscape

458

459

460

461

Local Variables:

462

mode:c++

463

c-file-style:"stroustrup"

464

c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))

465

indent-tabs-mode:nil

466

fill-column:99

467

End:

468

469

// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :

Older »