~ubuntu-branches/ubuntu/raring/qtwebkit-source/raring-proposed

SOFT_LINK(SafariTheme, paintThemePart, void, __stdcall, (ThemePart part, CGContextRef context, const CGRect& rect, NSControlSize size, ThemeControlState state), (part, context, rect, size, state))

#if defined(SAFARI_THEME_VERSION) && SAFARI_THEME_VERSION >= 2

SOFT_LINK(SafariTheme, STPaintProgressIndicator, void, APIENTRY, (ProgressIndicatorType type, CGContextRef context, const CGRect& rect, NSControlSize size, ThemeControlState state, float value), (type, context, rect, size, state, value))

100

#endif

101

SOFT_LINK_OPTIONAL(SafariTheme, STCopyThemeColor, CGColorRef, APIENTRY, (unsigned color, SafariTheme::ThemeControlState));

102

103

static const unsigned stFocusRingColorID = 4;

104

105

static const unsigned aquaFocusRingColor = 0xFF7DADD9;

106

107

static RGBA32 makeRGBAFromCGColor(CGColorRef color)

108

{

109

const CGFloat* components = CGColorGetComponents(color);

110

return makeRGBA(255 * components[0], 255 * components[1], 255 * components[2], 255 * components[3]);

111

}

112

113

ThemeControlState RenderThemeSafari::determineState(RenderObject* o) const

114

{

115

ThemeControlState result = 0;

116

if (isActive(o))

117

result |= SafariTheme::ActiveState;

118

if (isEnabled(o) && !isReadOnlyControl(o))

119

result |= SafariTheme::EnabledState;

120

if (isPressed(o))

121

result |= SafariTheme::PressedState;

122

if (isChecked(o))

123

result |= SafariTheme::CheckedState;

124

if (isIndeterminate(o))

125

result |= SafariTheme::IndeterminateCheckedState;

126

if (isFocused(o))

127

result |= SafariTheme::FocusedState;

128

if (isDefault(o))

129

result |= SafariTheme::DefaultState;

130

return result;

131

}

132

133

static NSControlSize controlSizeFromRect(const IntRect& rect, const IntSize sizes[])

134

{

135

if (sizes[NSRegularControlSize].height() == rect.height())

136

return NSRegularControlSize;

137

else if (sizes[NSMiniControlSize].height() == rect.height())

138

return NSMiniControlSize;

139

140

return NSSmallControlSize;

141

}

142

143

RenderThemeSafari::RenderThemeSafari()

144

{

145

}

146

147

RenderThemeSafari::~RenderThemeSafari()

148

{

149

}

150

151

Color RenderThemeSafari::platformActiveSelectionBackgroundColor() const

152

{

153

return Color(181, 213, 255);

154

}

155

156

Color RenderThemeSafari::platformInactiveSelectionBackgroundColor() const

157

{

158

return Color(212, 212, 212);

159

}

160

161

Color RenderThemeSafari::activeListBoxSelectionBackgroundColor() const

162

{

163

// FIXME: This should probably just be a darker version of the platformActiveSelectionBackgroundColor

164

return Color(56, 117, 215);

165

}

166

167

Color RenderThemeSafari::platformFocusRingColor() const

168

{

169

static Color focusRingColor;

170

171

if (!focusRingColor.isValid()) {

172

if (STCopyThemeColorPtr()) {

173

RetainPtr<CGColorRef> color(AdoptCF, STCopyThemeColorPtr()(stFocusRingColorID, SafariTheme::ActiveState));

174

focusRingColor = makeRGBAFromCGColor(color.get());

175

}

176

if (!focusRingColor.isValid())

177

focusRingColor = aquaFocusRingColor;

178

}

179

180

return focusRingColor;

181

}

182

183

static float systemFontSizeForControlSize(NSControlSize controlSize)

184

{

185

static float sizes[] = { 13.0f, 11.0f, 9.0f };

186

187

return sizes[controlSize];

188

}

189

190

void RenderThemeSafari::systemFont(int propId, FontDescription& fontDescription) const

191

{

192

static FontDescription systemFont;

193

static FontDescription smallSystemFont;

194

static FontDescription menuFont;

195

static FontDescription labelFont;

196

static FontDescription miniControlFont;

197

static FontDescription smallControlFont;

198

static FontDescription controlFont;

199

200

FontDescription* cachedDesc;

201

float fontSize = 0;

202

switch (propId) {

203

case CSSValueSmallCaption:

204

cachedDesc = &smallSystemFont;

205

if (!smallSystemFont.isAbsoluteSize())

206

fontSize = systemFontSizeForControlSize(NSSmallControlSize);

207

break;

208

case CSSValueMenu:

209

cachedDesc = &menuFont;

210

if (!menuFont.isAbsoluteSize())

211

fontSize = systemFontSizeForControlSize(NSRegularControlSize);

212

break;

213

case CSSValueStatusBar:

214

cachedDesc = &labelFont;

215

if (!labelFont.isAbsoluteSize())

216

fontSize = 10.0f;

217

break;

218

case CSSValueWebkitMiniControl:

219

cachedDesc = &miniControlFont;

220

if (!miniControlFont.isAbsoluteSize())

221

fontSize = systemFontSizeForControlSize(NSMiniControlSize);

222

break;

223

case CSSValueWebkitSmallControl:

224

cachedDesc = &smallControlFont;

225

if (!smallControlFont.isAbsoluteSize())

226

fontSize = systemFontSizeForControlSize(NSSmallControlSize);

227

break;

228

case CSSValueWebkitControl:

229

cachedDesc = &controlFont;

230

if (!controlFont.isAbsoluteSize())

231

fontSize = systemFontSizeForControlSize(NSRegularControlSize);

232

break;

233

default:

234

cachedDesc = &systemFont;

235

if (!systemFont.isAbsoluteSize())

236

fontSize = 13.0f;

237

}

238

239

if (fontSize) {

240

cachedDesc->setIsAbsoluteSize(true);

241

cachedDesc->setGenericFamily(FontDescription::NoFamily);

242

cachedDesc->firstFamily().setFamily("Lucida Grande");

243

cachedDesc->setSpecifiedSize(fontSize);

244

cachedDesc->setWeight(FontWeightNormal);

245

cachedDesc->setItalic(false);

246

}

247

fontDescription = *cachedDesc;

248

}

249

250

bool RenderThemeSafari::isControlStyled(const RenderStyle* style, const BorderData& border,

251

const FillLayer& background, const Color& backgroundColor) const

252

{

253

// If we didn't find SafariTheme.dll we won't be able to paint any themed controls.

254

if (!SafariThemeLibrary())

255

return true;

256

257

if (style->appearance() == TextFieldPart || style->appearance() == TextAreaPart || style->appearance() == ListboxPart)

258

return style->border() != border;

259

return RenderTheme::isControlStyled(style, border, background, backgroundColor);

260

}

261

262

void RenderThemeSafari::adjustRepaintRect(const RenderObject* o, IntRect& r)

263

{

264

NSControlSize controlSize = controlSizeForFont(o->style());

265

266

switch (o->style()->appearance()) {

267

case CheckboxPart: {

268

// We inflate the rect as needed to account for padding included in the cell to accommodate the checkbox

269

// shadow" and the check. We don't consider this part of the bounds of the control in WebKit.

270

r = inflateRect(r, checkboxSizes()[controlSize], checkboxMargins(controlSize));

271

break;

272

}

273

case RadioPart: {

274

// We inflate the rect as needed to account for padding included in the cell to accommodate the checkbox

275

// shadow" and the check. We don't consider this part of the bounds of the control in WebKit.

276

r = inflateRect(r, radioSizes()[controlSize], radioMargins(controlSize));

277

break;

278

}

279

case PushButtonPart:

280

case DefaultButtonPart:

281

case ButtonPart: {

282

// We inflate the rect as needed to account for padding included in the cell to accommodate the checkbox

283

// shadow" and the check. We don't consider this part of the bounds of the control in WebKit.

284

if (r.height() <= buttonSizes()[NSRegularControlSize].height())

285

r = inflateRect(r, buttonSizes()[controlSize], buttonMargins(controlSize));

286

break;

287

}

288

case MenulistPart: {

289

r = inflateRect(r, popupButtonSizes()[controlSize], popupButtonMargins(controlSize));

290

break;

291

}

292

default:

293

break;

294

}

295

}

296

297

IntRect RenderThemeSafari::inflateRect(const IntRect& r, const IntSize& size, const int* margins) const

298

{

299

// Only do the inflation if the available width/height are too small. Otherwise try to

300

// fit the glow/check space into the available box's width/height.

301

int widthDelta = r.width() - (size.width() + margins[leftMargin] + margins[rightMargin]);

302

int heightDelta = r.height() - (size.height() + margins[topMargin] + margins[bottomMargin]);

303

IntRect result(r);

304

if (widthDelta < 0) {

305

result.setX(result.x() - margins[leftMargin]);

306

result.setWidth(result.width() - widthDelta);

307

}

308

if (heightDelta < 0) {

309

result.setY(result.y() - margins[topMargin]);

310

result.setHeight(result.height() - heightDelta);

311

}

312

return result;

313

}

314

315

int RenderThemeSafari::baselinePosition(const RenderObject* o) const

316

{

317

if (!o->isBox())

318

return 0;

319

320

if (o->style()->appearance() == CheckboxPart || o->style()->appearance() == RadioPart) {

321

const RenderBox* box = toRenderBox(o);

322

return box->marginTop() + box->height() - 2; // The baseline is 2px up from the bottom of the checkbox/radio in AppKit.

323

}

324

325

return RenderTheme::baselinePosition(o);

326

}

327

328

bool RenderThemeSafari::controlSupportsTints(const RenderObject* o) const

329

{

330

if (!isEnabled(o))

331

return false;

332

333

// Checkboxes only have tint when checked.

334

if (o->style()->appearance() == CheckboxPart)

335

return isChecked(o);

336

337

// For now assume other controls have tint if enabled.

338

return true;

339

}

340

341

NSControlSize RenderThemeSafari::controlSizeForFont(RenderStyle* style) const

342

{

343

int fontSize = style->fontSize();

344

if (fontSize >= 16)

345

return NSRegularControlSize;

346

if (fontSize >= 11)

347

return NSSmallControlSize;

348

return NSMiniControlSize;

349

}

350

351

void RenderThemeSafari::setControlSize(NSCell* cell, const IntSize* sizes, const IntSize& minSize)

352

{

353

NSControlSize size;

354

if (minSize.width() >= sizes[NSRegularControlSize].width() &&

355

minSize.height() >= sizes[NSRegularControlSize].height())

356

size = NSRegularControlSize;

357

else if (minSize.width() >= sizes[NSSmallControlSize].width() &&

358

minSize.height() >= sizes[NSSmallControlSize].height())

359

size = NSSmallControlSize;

360

else

361

size = NSMiniControlSize;

362

if (size != [cell controlSize]) // Only update if we have to, since AppKit does work even if the size is the same.

363

[cell setControlSize:size];

364

}

365

366

IntSize RenderThemeSafari::sizeForFont(RenderStyle* style, const IntSize* sizes) const

367

{

368

return sizes[controlSizeForFont(style)];

369

}

370

371

IntSize RenderThemeSafari::sizeForSystemFont(RenderStyle* style, const IntSize* sizes) const

372

{

373

return sizes[controlSizeForSystemFont(style)];

374

}

375

376

void RenderThemeSafari::setSizeFromFont(RenderStyle* style, const IntSize* sizes) const

377

{

378

// FIXME: Check is flawed, since it doesn't take min-width/max-width into account.

379

IntSize size = sizeForFont(style, sizes);

380

if (style->width().isIntrinsicOrAuto() && size.width() > 0)

381

style->setWidth(Length(size.width(), Fixed));

382

if (style->height().isAuto() && size.height() > 0)

383

style->setHeight(Length(size.height(), Fixed));

384

}

385

386

void RenderThemeSafari::setFontFromControlSize(StyleResolver* styleResolver, RenderStyle* style, NSControlSize controlSize) const

387

{

388

FontDescription fontDescription;

389

fontDescription.setIsAbsoluteSize(true);

390

fontDescription.setGenericFamily(FontDescription::SerifFamily);

391

392

float fontSize = systemFontSizeForControlSize(controlSize);

393

fontDescription.firstFamily().setFamily("Lucida Grande");

394

fontDescription.setComputedSize(fontSize);

395

fontDescription.setSpecifiedSize(fontSize);

396

397

// Reset line height

398

style->setLineHeight(RenderStyle::initialLineHeight());

399

400

if (style->setFontDescription(fontDescription))

401

style->font().update(styleResolver->fontSelector());

402

}

403

404

NSControlSize RenderThemeSafari::controlSizeForSystemFont(RenderStyle* style) const

405

{

406

int fontSize = style->fontSize();

407

if (fontSize >= 13)

408

return NSRegularControlSize;

409

if (fontSize >= 11)

410

return NSSmallControlSize;

411

return NSMiniControlSize;

412

}

413

414

bool RenderThemeSafari::paintCheckbox(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

415

{

416

ASSERT(SafariThemeLibrary());

417

418

NSControlSize controlSize = controlSizeForFont(o->style());

419

420

IntRect inflatedRect = inflateRect(r, checkboxSizes()[controlSize], checkboxMargins(controlSize));

421

paintThemePart(SafariTheme::CheckboxPart, paintInfo.context->platformContext(), inflatedRect, controlSize, determineState(o));

422

423

return false;

424

}

425

426

const IntSize* RenderThemeSafari::checkboxSizes() const

427

{

428

static const IntSize sizes[3] = { IntSize(14, 14), IntSize(12, 12), IntSize(10, 10) };

429

return sizes;

430

}

431

432

const int* RenderThemeSafari::checkboxMargins(NSControlSize controlSize) const

433

{

434

static const int margins[3][4] =

435

{

436

{ 2, 2, 2, 2 },

437

{ 2, 2, 2, 1 },

438

{ 1, 0, 0, 0 },

439

};

440

return margins[controlSize];

441

}

442

443

void RenderThemeSafari::setCheckboxSize(RenderStyle* style) const

444

{

445

// If the width and height are both specified, then we have nothing to do.

446

if (!style->width().isIntrinsicOrAuto() && !style->height().isAuto())

447

return;

448

449

// Use the font size to determine the intrinsic width of the control.

450

setSizeFromFont(style, checkboxSizes());

451

}

452

453

bool RenderThemeSafari::paintRadio(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

454

{

455

ASSERT(SafariThemeLibrary());

456

457

NSControlSize controlSize = controlSizeForFont(o->style());

458

459

IntRect inflatedRect = inflateRect(r, radioSizes()[controlSize], radioMargins(controlSize));

460

paintThemePart(RadioButtonPart, paintInfo.context->platformContext(), inflatedRect, controlSize, determineState(o));

461

462

return false;

463

}

464

465

const IntSize* RenderThemeSafari::radioSizes() const

466

{

467

static const IntSize sizes[3] = { IntSize(14, 15), IntSize(12, 13), IntSize(10, 10) };

468

return sizes;

469

}

470

471

const int* RenderThemeSafari::radioMargins(NSControlSize controlSize) const

472

{

473

static const int margins[3][4] =

474

{

475

{ 1, 2, 2, 2 },

476

{ 0, 1, 2, 1 },

477

{ 0, 0, 1, 0 },

478

};

479

return margins[controlSize];

480

}

481

482

void RenderThemeSafari::setRadioSize(RenderStyle* style) const

483

{

484

// If the width and height are both specified, then we have nothing to do.

485

if (!style->width().isIntrinsicOrAuto() && !style->height().isAuto())

486

return;

487

488

// Use the font size to determine the intrinsic width of the control.

489

setSizeFromFont(style, radioSizes());

490

}

491

492

void RenderThemeSafari::setButtonPaddingFromControlSize(RenderStyle* style, NSControlSize size) const

493

{

494

// Just use 8px. AppKit wants to use 11px for mini buttons, but that padding is just too large

495

// for real-world Web sites (creating a huge necessary minimum width for buttons whose space is

496

// by definition constrained, since we select mini only for small cramped environments.

497

// This also guarantees the HTML4 <button> will match our rendering by default, since we're using a consistent

498

// padding.

499

const int padding = 8;

500

style->setPaddingLeft(Length(padding, Fixed));

501

style->setPaddingRight(Length(padding, Fixed));

502

style->setPaddingTop(Length(0, Fixed));

503

style->setPaddingBottom(Length(0, Fixed));

504

}

505

506

void RenderThemeSafari::adjustButtonStyle(StyleResolver* styleResolver, RenderStyle* style, Element* e) const

507

{

508

// There are three appearance constants for buttons.

509

// (1) Push-button is the constant for the default Aqua system button. Push buttons will not scale vertically and will not allow

510

// custom fonts or colors. <input>s use this constant. This button will allow custom colors and font weights/variants but won't

511

// scale vertically.

512

// (2) square-button is the constant for the square button. This button will allow custom fonts and colors and will scale vertically.

513

// (3) Button is the constant that means "pick the best button as appropriate." <button>s use this constant. This button will

514

// also scale vertically and allow custom fonts and colors. It will attempt to use Aqua if possible and will make this determination

515

// solely on the rectangle of the control.

516

517

// Determine our control size based off our font.

518

NSControlSize controlSize = controlSizeForFont(style);

519

520

if (style->appearance() == PushButtonPart) {

521

// Ditch the border.

522

style->resetBorder();

523

524

// Height is locked to auto.

525

style->setHeight(Length(Auto));

526

527

// White-space is locked to pre

528

style->setWhiteSpace(PRE);

529

530

// Set the button's vertical size.

531

setButtonSize(style);

532

533

// Add in the padding that we'd like to use.

534

setButtonPaddingFromControlSize(style, controlSize);

535

536

// Our font is locked to the appropriate system font size for the control. To clarify, we first use the CSS-specified font to figure out

537

// a reasonable control size, but once that control size is determined, we throw that font away and use the appropriate

538

// system font for the control size instead.

539

setFontFromControlSize(styleResolver, style, controlSize);

540

} else {

541

// Set a min-height so that we can't get smaller than the mini button.

542

style->setMinHeight(Length(15, Fixed));

543

544

// Reset the top and bottom borders.

545

style->resetBorderTop();

546

style->resetBorderBottom();

547

}

548

}

549

550

const IntSize* RenderThemeSafari::buttonSizes() const

551

{

552

static const IntSize sizes[3] = { IntSize(0, 21), IntSize(0, 18), IntSize(0, 15) };

553

return sizes;

554

}

555

556

const int* RenderThemeSafari::buttonMargins(NSControlSize controlSize) const

557

{

558

static const int margins[3][4] =

559

{

560

{ 4, 6, 7, 6 },

561

{ 4, 5, 6, 5 },

562

{ 0, 1, 1, 1 },

563

};

564

return margins[controlSize];

565

}

566

567

void RenderThemeSafari::setButtonSize(RenderStyle* style) const

568

{

569

// If the width and height are both specified, then we have nothing to do.

570

if (!style->width().isIntrinsicOrAuto() && !style->height().isAuto())

571

return;

572

573

// Use the font size to determine the intrinsic width of the control.

574

setSizeFromFont(style, buttonSizes());

575

}

576

577

bool RenderThemeSafari::paintButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

578

{

579

ASSERT(SafariThemeLibrary());

580

581

// We inflate the rect as needed to account for padding included in the cell to accommodate the button

582

// shadow. We don't consider this part of the bounds of the control in WebKit.

583

584

NSControlSize controlSize = controlSizeFromRect(r, buttonSizes());

585

IntRect inflatedRect = r;

586

587

ThemePart part;

588

if (r.height() <= buttonSizes()[NSRegularControlSize].height()) {

589

// Push button

590

part = SafariTheme::PushButtonPart;

591

592

IntSize size = buttonSizes()[controlSize];

593

size.setWidth(r.width());

594

595

// Center the button within the available space.

596

if (inflatedRect.height() > size.height()) {

597

inflatedRect.setY(inflatedRect.y() + (inflatedRect.height() - size.height()) / 2);

598

inflatedRect.setHeight(size.height());

599

}

600

601

// Now inflate it to account for the shadow.

602

inflatedRect = inflateRect(inflatedRect, size, buttonMargins(controlSize));

603

} else

604

part = SafariTheme::SquareButtonPart;

605

606

paintThemePart(part, paintInfo.context->platformContext(), inflatedRect, controlSize, determineState(o));

607

return false;

608

}

609

610

bool RenderThemeSafari::paintTextField(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

611

{

612

ASSERT(SafariThemeLibrary());

613

614

paintThemePart(SafariTheme::TextFieldPart, paintInfo.context->platformContext(), r, (NSControlSize)0, determineState(o) & ~FocusedState);

615

return false;

616

}

617

618

void RenderThemeSafari::adjustTextFieldStyle(StyleResolver*, RenderStyle*, Element*) const

619

{

620

}

621

622

bool RenderThemeSafari::paintCapsLockIndicator(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

623

{

624

#if defined(SAFARI_THEME_VERSION) && SAFARI_THEME_VERSION >= 1

625

ASSERT(SafariThemeLibrary());

626

627

if (paintInfo.context->paintingDisabled())

628

return true;

629

630

paintThemePart(CapsLockPart, paintInfo.context->platformContext(), r, (NSControlSize)0, (ThemeControlState)0);

631

632

return false;

633

#else

634

return true;

635

#endif

636

}

637

638

bool RenderThemeSafari::paintTextArea(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

639

{

640

ASSERT(SafariThemeLibrary());

641

642

paintThemePart(SafariTheme::TextAreaPart, paintInfo.context->platformContext(), r, (NSControlSize)0, determineState(o) & ~FocusedState);

643

return false;

644

}

645

646

void RenderThemeSafari::adjustTextAreaStyle(StyleResolver*, RenderStyle*, Element*) const

647

{

648

}

649

650

const int* RenderThemeSafari::popupButtonMargins(NSControlSize size) const

651

{

652

static const int margins[3][4] =

653

{

654

{ 2, 3, 3, 3 },

655

{ 1, 3, 3, 3 },

656

{ 0, 1, 0, 1 }

657

};

658

return margins[size];

659

}

660

661

const IntSize* RenderThemeSafari::popupButtonSizes() const

662

{

663

static const IntSize sizes[3] = { IntSize(0, 21), IntSize(0, 18), IntSize(0, 15) };

664

return sizes;

665

}

666

667

const int* RenderThemeSafari::popupButtonPadding(NSControlSize size) const

668

{

669

static const int padding[3][4] =

670

{

671

{ 2, 26, 3, 8 },

672

{ 2, 23, 3, 8 },

673

{ 2, 22, 3, 10 }

674

};

675

return padding[size];

676

}

677

678

bool RenderThemeSafari::paintMenuList(RenderObject* o, const PaintInfo& info, const IntRect& r)

679

{

680

ASSERT(SafariThemeLibrary());

681

682

NSControlSize controlSize = controlSizeFromRect(r, popupButtonSizes());

683

IntRect inflatedRect = r;

684

IntSize size = popupButtonSizes()[controlSize];

685

size.setWidth(r.width());

686

687

// Now inflate it to account for the shadow.

688

if (r.width() >= minimumMenuListSize(o->style()))

689

inflatedRect = inflateRect(inflatedRect, size, popupButtonMargins(controlSize));

690

691

paintThemePart(DropDownButtonPart, info.context->platformContext(), inflatedRect, controlSize, determineState(o));

692

693

return false;

694

}

695

696

const float baseFontSize = 11.0f;

697

const float baseArrowHeight = 5.0f;

698

const float baseArrowWidth = 7.0f;

699

const int arrowPaddingLeft = 5;

700

const int arrowPaddingRight = 5;

701

const int paddingBeforeSeparator = 4;

702

const int baseBorderRadius = 5;

703

const int styledPopupPaddingLeft = 8;

704

const int styledPopupPaddingTop = 1;

705

const int styledPopupPaddingBottom = 2;

706

707

static void TopGradientInterpolate(void* info, const CGFloat* inData, CGFloat* outData)

708

{

709

static float dark[4] = { 1.0f, 1.0f, 1.0f, 0.4f };

710

static float light[4] = { 1.0f, 1.0f, 1.0f, 0.15f };

711

float a = inData[0];

712

int i = 0;

713

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

714

outData[i] = (1.0f - a) * dark[i] + a * light[i];

715

}

716

717

static void BottomGradientInterpolate(void* info, const CGFloat* inData, CGFloat* outData)

718

{

719

static float dark[4] = { 1.0f, 1.0f, 1.0f, 0.0f };

720

static float light[4] = { 1.0f, 1.0f, 1.0f, 0.3f };

721

float a = inData[0];

722

int i = 0;

723

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

724

outData[i] = (1.0f - a) * dark[i] + a * light[i];

725

}

726

727

static void MainGradientInterpolate(void* info, const CGFloat* inData, CGFloat* outData)

728

{

729

static float dark[4] = { 0.0f, 0.0f, 0.0f, 0.15f };

730

static float light[4] = { 0.0f, 0.0f, 0.0f, 0.0f };

731

float a = inData[0];

732

int i = 0;

733

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

734

outData[i] = (1.0f - a) * dark[i] + a * light[i];

735

}

736

737

static void TrackGradientInterpolate(void* info, const CGFloat* inData, CGFloat* outData)

738

{

739

static float dark[4] = { 0.0f, 0.0f, 0.0f, 0.678f };

740

static float light[4] = { 0.0f, 0.0f, 0.0f, 0.13f };

741

float a = inData[0];

742

int i = 0;

743

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

744

outData[i] = (1.0f - a) * dark[i] + a * light[i];

745

}

746

747

void RenderThemeSafari::paintMenuListButtonGradients(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

748

{

749

if (r.isEmpty())

750

return;

751

752

CGContextRef context = paintInfo.context->platformContext();

753

754

paintInfo.context->save();

755

756

RoundedRect bound = o->style()->getRoundedBorderFor(r);

757

int radius = bound.radii().topLeft().width();

758

759

CGColorSpaceRef cspace = deviceRGBColorSpaceRef();

760

761

FloatRect topGradient(r.x(), r.y(), r.width(), r.height() / 2.0f);

762

struct CGFunctionCallbacks topCallbacks = { 0, TopGradientInterpolate, NULL };

763

RetainPtr<CGFunctionRef> topFunction(AdoptCF, CGFunctionCreate(NULL, 1, NULL, 4, NULL, &topCallbacks));

764

RetainPtr<CGShadingRef> topShading(AdoptCF, CGShadingCreateAxial(cspace, CGPointMake(topGradient.x(), topGradient.y()), CGPointMake(topGradient.x(), topGradient.maxY()), topFunction.get(), false, false));

765

766

FloatRect bottomGradient(r.x() + radius, r.y() + r.height() / 2.0f, r.width() - 2.0f * radius, r.height() / 2.0f);

767

struct CGFunctionCallbacks bottomCallbacks = { 0, BottomGradientInterpolate, NULL };

768

RetainPtr<CGFunctionRef> bottomFunction(AdoptCF, CGFunctionCreate(NULL, 1, NULL, 4, NULL, &bottomCallbacks));

769

RetainPtr<CGShadingRef> bottomShading(AdoptCF, CGShadingCreateAxial(cspace, CGPointMake(bottomGradient.x(), bottomGradient.y()), CGPointMake(bottomGradient.x(), bottomGradient.maxY()), bottomFunction.get(), false, false));

770

771

struct CGFunctionCallbacks mainCallbacks = { 0, MainGradientInterpolate, NULL };

772

RetainPtr<CGFunctionRef> mainFunction(AdoptCF, CGFunctionCreate(NULL, 1, NULL, 4, NULL, &mainCallbacks));

773

RetainPtr<CGShadingRef> mainShading(AdoptCF, CGShadingCreateAxial(cspace, CGPointMake(r.x(), r.y()), CGPointMake(r.x(), r.maxY()), mainFunction.get(), false, false));

774

775

RetainPtr<CGShadingRef> leftShading(AdoptCF, CGShadingCreateAxial(cspace, CGPointMake(r.x(), r.y()), CGPointMake(r.x() + radius, r.y()), mainFunction.get(), false, false));

776

777

RetainPtr<CGShadingRef> rightShading(AdoptCF, CGShadingCreateAxial(cspace, CGPointMake(r.maxX(), r.y()), CGPointMake(r.maxX() - radius, r.y()), mainFunction.get(), false, false));

778

paintInfo.context->save();

779

CGContextClipToRect(context, bound.rect());

780

paintInfo.context->addRoundedRectClip(bound);

781

CGContextDrawShading(context, mainShading.get());

782

paintInfo.context->restore();

783

784

paintInfo.context->save();

785

CGContextClipToRect(context, topGradient);

786

paintInfo.context->addRoundedRectClip(RoundedRect(enclosingIntRect(topGradient), bound.radii().topLeft(), bound.radii().topRight(), IntSize(), IntSize()));

787

CGContextDrawShading(context, topShading.get());

788

paintInfo.context->restore();

789

790

if (!bottomGradient.isEmpty()) {

791

paintInfo.context->save();

792

CGContextClipToRect(context, bottomGradient);

793

paintInfo.context->addRoundedRectClip(RoundedRect(enclosingIntRect(bottomGradient), IntSize(), IntSize(), bound.radii().bottomLeft(), bound.radii().bottomRight()));

794

CGContextDrawShading(context, bottomShading.get());

795

paintInfo.context->restore();

796

}

797

798

paintInfo.context->save();

799

CGContextClipToRect(context, bound.rect());

800

paintInfo.context->addRoundedRectClip(bound);

801

CGContextDrawShading(context, leftShading.get());

802

CGContextDrawShading(context, rightShading.get());

803

paintInfo.context->restore();

804

805

paintInfo.context->restore();

806

}

807

808

bool RenderThemeSafari::paintMenuListButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

809

{

810

IntRect bounds = IntRect(r.x() + o->style()->borderLeftWidth(),

811

r.y() + o->style()->borderTopWidth(),

812

r.width() - o->style()->borderLeftWidth() - o->style()->borderRightWidth(),

813

r.height() - o->style()->borderTopWidth() - o->style()->borderBottomWidth());

814

// Draw the gradients to give the styled popup menu a button appearance

815

paintMenuListButtonGradients(o, paintInfo, bounds);

816

817

// Since we actually know the size of the control here, we restrict the font scale to make sure the arrow will fit vertically in the bounds

818

float fontScale = min(o->style()->fontSize() / baseFontSize, bounds.height() / baseArrowHeight);

819

float centerY = bounds.y() + bounds.height() / 2.0f;

820

float arrowHeight = baseArrowHeight * fontScale;

821

float arrowWidth = baseArrowWidth * fontScale;

822

float leftEdge = bounds.maxX() - arrowPaddingRight - arrowWidth;

823

824

if (bounds.width() < arrowWidth + arrowPaddingLeft)

825

return false;

826

827

paintInfo.context->save();

828

829

paintInfo.context->setFillColor(o->style()->visitedDependentColor(CSSPropertyColor), ColorSpaceDeviceRGB);

830

paintInfo.context->setStrokeColor(NoStroke, ColorSpaceDeviceRGB);

831

832

FloatPoint arrow[3];

833

arrow[0] = FloatPoint(leftEdge, centerY - arrowHeight / 2.0f);

834

arrow[1] = FloatPoint(leftEdge + arrowWidth, centerY - arrowHeight / 2.0f);

835

arrow[2] = FloatPoint(leftEdge + arrowWidth / 2.0f, centerY + arrowHeight / 2.0f);

836

837

// Draw the arrow

838

paintInfo.context->drawConvexPolygon(3, arrow, true);

839

840

Color leftSeparatorColor(0, 0, 0, 40);

841

Color rightSeparatorColor(255, 255, 255, 40);

842

843

// FIXME: Should the separator thickness and space be scaled up by fontScale?

844

int separatorSpace = 2;

845

int leftEdgeOfSeparator = static_cast<int>(leftEdge - arrowPaddingLeft); // FIXME: Round?

846

847

// Draw the separator to the left of the arrows

848

paintInfo.context->setStrokeThickness(1.0f);

849

paintInfo.context->setStrokeStyle(SolidStroke);

850

paintInfo.context->setStrokeColor(leftSeparatorColor, ColorSpaceDeviceRGB);

851

paintInfo.context->drawLine(IntPoint(leftEdgeOfSeparator, bounds.y()),

852

IntPoint(leftEdgeOfSeparator, bounds.maxY()));

853

854

paintInfo.context->setStrokeColor(rightSeparatorColor, ColorSpaceDeviceRGB);

855

paintInfo.context->drawLine(IntPoint(leftEdgeOfSeparator + separatorSpace, bounds.y()),

856

IntPoint(leftEdgeOfSeparator + separatorSpace, bounds.maxY()));

857

858

paintInfo.context->restore();

859

return false;

860

}

861

862

void RenderThemeSafari::adjustMenuListStyle(StyleResolver* styleResolver, RenderStyle* style, Element* e) const

863

{

864

NSControlSize controlSize = controlSizeForFont(style);

865

866

style->resetBorder();

867

style->resetPadding();

868

869

// Height is locked to auto.

870

style->setHeight(Length(Auto));

871

872

// White-space is locked to pre

873

style->setWhiteSpace(PRE);

874

875

// Set the foreground color to black or gray when we have the aqua look.

876

// Cast to RGB32 is to work around a compiler bug.

877

style->setColor(e && e->isEnabledFormControl() ? static_cast<RGBA32>(Color::black) : Color::darkGray);

878

879

// Set the button's vertical size.

880

setButtonSize(style);

881

882

// Our font is locked to the appropriate system font size for the control. To clarify, we first use the CSS-specified font to figure out

883

// a reasonable control size, but once that control size is determined, we throw that font away and use the appropriate

884

// system font for the control size instead.

885

setFontFromControlSize(styleResolver, style, controlSize);

886

}

887

888

int RenderThemeSafari::popupInternalPaddingLeft(RenderStyle* style) const

889

{

890

if (style->appearance() == MenulistPart)

891

return popupButtonPadding(controlSizeForFont(style))[leftPadding];

892

if (style->appearance() == MenulistButtonPart)

893

return styledPopupPaddingLeft;

894

return 0;

895

}

896

897

int RenderThemeSafari::popupInternalPaddingRight(RenderStyle* style) const

898

{

899

if (style->appearance() == MenulistPart)

900

return popupButtonPadding(controlSizeForFont(style))[rightPadding];

901

if (style->appearance() == MenulistButtonPart) {

902

float fontScale = style->fontSize() / baseFontSize;

903

float arrowWidth = baseArrowWidth * fontScale;

904

return static_cast<int>(ceilf(arrowWidth + arrowPaddingLeft + arrowPaddingRight + paddingBeforeSeparator));

905

}

906

return 0;

907

}

908

909

int RenderThemeSafari::popupInternalPaddingTop(RenderStyle* style) const

910

{

911

if (style->appearance() == MenulistPart)

912

return popupButtonPadding(controlSizeForFont(style))[topPadding];

913

if (style->appearance() == MenulistButtonPart)

914

return styledPopupPaddingTop;

915

return 0;

916

}

917

918

int RenderThemeSafari::popupInternalPaddingBottom(RenderStyle* style) const

919

{

920

if (style->appearance() == MenulistPart)

921

return popupButtonPadding(controlSizeForFont(style))[bottomPadding];

922

if (style->appearance() == MenulistButtonPart)

923

return styledPopupPaddingBottom;

924

return 0;

925

}

926

927

void RenderThemeSafari::adjustMenuListButtonStyle(StyleResolver*, RenderStyle* style, Element*) const

928

{

929

float fontScale = style->fontSize() / baseFontSize;

930

931

style->resetPadding();

932

style->setBorderRadius(IntSize(int(baseBorderRadius + fontScale - 1), int(baseBorderRadius + fontScale - 1))); // FIXME: Round up?

933

934

const int minHeight = 15;

935

style->setMinHeight(Length(minHeight, Fixed));

936

937

style->setLineHeight(RenderStyle::initialLineHeight());

938

}

939

940

const IntSize* RenderThemeSafari::menuListSizes() const

941

{

942

static const IntSize sizes[3] = { IntSize(9, 0), IntSize(5, 0), IntSize(0, 0) };

943

return sizes;

944

}

945

946

int RenderThemeSafari::minimumMenuListSize(RenderStyle* style) const

947

{

948

return sizeForSystemFont(style, menuListSizes()).width();

949

}

950

951

const int trackWidth = 5;

952

const int trackRadius = 2;

953

954

bool RenderThemeSafari::paintSliderTrack(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

955

{

956

IntSize radius(trackRadius, trackRadius);

957

RoundedRect bounds(r, radius, radius, radius, radius);

958

959

if (o->style()->appearance() == SliderHorizontalPart)

960

bounds.setRect(IntRect(r.x(),

961

r.y() + r.height() / 2 - trackWidth / 2,

962

r.width(),

963

trackWidth));

964

else if (o->style()->appearance() == SliderVerticalPart)

965

bounds.setRect(IntRect(r.x() + r.width() / 2 - trackWidth / 2,

966

r.y(),

967

trackWidth,

968

r.height()));

969

970

CGContextRef context = paintInfo.context->platformContext();

971

CGColorSpaceRef cspace = deviceRGBColorSpaceRef();

972

973

paintInfo.context->save();

974

CGContextClipToRect(context, bounds.rect());

975

976

struct CGFunctionCallbacks mainCallbacks = { 0, TrackGradientInterpolate, NULL };

977

RetainPtr<CGFunctionRef> mainFunction(AdoptCF, CGFunctionCreate(NULL, 1, NULL, 4, NULL, &mainCallbacks));

978

RetainPtr<CGShadingRef> mainShading;

979

if (o->style()->appearance() == SliderVerticalPart)

980

mainShading.adoptCF(CGShadingCreateAxial(cspace, CGPointMake(bounds.rect().x(), bounds.rect().maxY()), CGPointMake(bounds.rect().maxX(), bounds.rect().maxY()), mainFunction.get(), false, false));

981

else

982

mainShading.adoptCF(CGShadingCreateAxial(cspace, CGPointMake(bounds.rect().x(), bounds.rect().y()), CGPointMake(bounds.rect().x(), bounds.rect().maxY()), mainFunction.get(), false, false));

983

984

paintInfo.context->addRoundedRectClip(bounds);

985

CGContextDrawShading(context, mainShading.get());

986

paintInfo.context->restore();

987

988

return false;

989

}

990

991

void RenderThemeSafari::adjustSliderThumbStyle(StyleResolver* styleResolver, RenderStyle* style, Element* e) const

992

{

993

RenderTheme::adjustSliderThumbStyle(styleResolver, style, e);

994

style->setBoxShadow(nullptr);

995

}

996

997

const float verticalSliderHeightPadding = 0.1f;

998

999

bool RenderThemeSafari::paintSliderThumb(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

1000

{

1001

ASSERT(SafariThemeLibrary());

1002

paintThemePart(SliderThumbPart, paintInfo.context->platformContext(), r, NSSmallControlSize, determineState(o));

1003

return false;

1004

}

1005

1006

const int sliderThumbWidth = 15;

1007

const int sliderThumbHeight = 15;

1008

1009

void RenderThemeSafari::adjustSliderThumbSize(RenderStyle* style, Element*) const

1010

{

1011

if (style->appearance() == SliderThumbHorizontalPart || style->appearance() == SliderThumbVerticalPart) {

1012

style->setWidth(Length(sliderThumbWidth, Fixed));

1013

style->setHeight(Length(sliderThumbHeight, Fixed));

1014

}

1015

#if ENABLE(VIDEO)

1016

else if (style->appearance() == MediaSliderThumbPart)

1017

RenderMediaControls::adjustMediaSliderThumbSize(style);

1018

#endif

1019

}

1020

1021

bool RenderThemeSafari::paintSearchField(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

1022

{

1023

ASSERT(SafariThemeLibrary());

1024

1025

paintThemePart(SafariTheme::SearchFieldPart, paintInfo.context->platformContext(), r, controlSizeFromRect(r, searchFieldSizes()), determineState(o));

1026

return false;

1027

}

1028

1029

const IntSize* RenderThemeSafari::searchFieldSizes() const

1030

{

1031

static const IntSize sizes[3] = { IntSize(0, 22), IntSize(0, 19), IntSize(0, 15) };

1032

return sizes;

1033

}

1034

1035

void RenderThemeSafari::setSearchFieldSize(RenderStyle* style) const

1036

{

1037

// If the width and height are both specified, then we have nothing to do.

1038

if (!style->width().isIntrinsicOrAuto() && !style->height().isAuto())

1039

return;

1040

1041

// Use the font size to determine the intrinsic width of the control.

1042

setSizeFromFont(style, searchFieldSizes());

1043

}

1044

1045

void RenderThemeSafari::adjustSearchFieldStyle(StyleResolver* styleResolver, RenderStyle* style, Element* e) const

1046

{

1047

// Override border.

1048

style->resetBorder();

1049

const short borderWidth = 2;

1050

style->setBorderLeftWidth(borderWidth);

1051

style->setBorderLeftStyle(INSET);

1052

style->setBorderRightWidth(borderWidth);

1053

style->setBorderRightStyle(INSET);

1054

style->setBorderBottomWidth(borderWidth);

1055

style->setBorderBottomStyle(INSET);

1056

style->setBorderTopWidth(borderWidth);

1057

style->setBorderTopStyle(INSET);

1058

1059

// Override height.

1060

style->setHeight(Length(Auto));

1061

setSearchFieldSize(style);

1062

1063

// Override padding size to match AppKit text positioning.

1064

const int padding = 1;

1065

style->setPaddingLeft(Length(padding, Fixed));

1066

style->setPaddingRight(Length(padding, Fixed));

1067

style->setPaddingTop(Length(padding, Fixed));

1068

style->setPaddingBottom(Length(padding, Fixed));

1069

1070

NSControlSize controlSize = controlSizeForFont(style);

1071

setFontFromControlSize(styleResolver, style, controlSize);

1072

}

1073

1074

bool RenderThemeSafari::paintSearchFieldCancelButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect&)

1075

{

1076

ASSERT(SafariThemeLibrary());

1077

1078

Node* input = o->node()->shadowHost();

1079

if (!input)

1080

input = o->node();

1081

RenderObject* renderer = input->renderer();

1082

ASSERT(renderer);

1083

1084

IntRect searchRect = renderer->absoluteBoundingBoxRectIgnoringTransforms();

1085

1086

paintThemePart(SafariTheme::SearchFieldCancelButtonPart, paintInfo.context->platformContext(), searchRect, controlSizeFromRect(searchRect, searchFieldSizes()), determineState(o));

1087

return false;

1088

}

1089

1090

const IntSize* RenderThemeSafari::cancelButtonSizes() const

1091

{

1092

static const IntSize sizes[3] = { IntSize(16, 13), IntSize(13, 11), IntSize(13, 9) };

1093

return sizes;

1094

}

1095

1096

void RenderThemeSafari::adjustSearchFieldCancelButtonStyle(StyleResolver*, RenderStyle* style, Element*) const

1097

{

1098

IntSize size = sizeForSystemFont(style, cancelButtonSizes());

1099

style->setWidth(Length(size.width(), Fixed));

1100

style->setHeight(Length(size.height(), Fixed));

1101

}

1102

1103

const IntSize* RenderThemeSafari::resultsButtonSizes() const

1104

{

1105

static const IntSize sizes[3] = { IntSize(19, 13), IntSize(17, 11), IntSize(17, 9) };

1106

return sizes;

1107

}

1108

1109

const int emptyResultsOffset = 9;

1110

void RenderThemeSafari::adjustSearchFieldDecorationStyle(StyleResolver*, RenderStyle* style, Element*) const

1111

{

1112

IntSize size = sizeForSystemFont(style, resultsButtonSizes());

1113

style->setWidth(Length(size.width() - emptyResultsOffset, Fixed));

1114

style->setHeight(Length(size.height(), Fixed));

1115

}

1116

1117

bool RenderThemeSafari::paintSearchFieldDecoration(RenderObject*, const PaintInfo&, const IntRect&)

1118

{

1119

return false;

1120

}

1121

1122

void RenderThemeSafari::adjustSearchFieldResultsDecorationStyle(StyleResolver*, RenderStyle* style, Element*) const

1123

{

1124

IntSize size = sizeForSystemFont(style, resultsButtonSizes());

1125

style->setWidth(Length(size.width(), Fixed));

1126

style->setHeight(Length(size.height(), Fixed));

1127

}

1128

1129

bool RenderThemeSafari::paintSearchFieldResultsDecoration(RenderObject* o, const PaintInfo& paintInfo, const IntRect&)

1130

{

1131

ASSERT(SafariThemeLibrary());

1132

1133

Node* input = o->node()->shadowHost();

1134

if (!input)

1135

input = o->node();

1136

RenderObject* renderer = input->renderer();

1137

ASSERT(renderer);

1138

1139

IntRect searchRect = renderer->absoluteBoundingBoxRectIgnoringTransforms();

1140

1141

paintThemePart(SafariTheme::SearchFieldResultsDecorationPart, paintInfo.context->platformContext(), searchRect, controlSizeFromRect(searchRect, searchFieldSizes()), determineState(o));

1142

return false;

1143

}

1144

1145

const int resultsArrowWidth = 5;

1146

void RenderThemeSafari::adjustSearchFieldResultsButtonStyle(StyleResolver*, RenderStyle* style, Element*) const

1147

{

1148

IntSize size = sizeForSystemFont(style, resultsButtonSizes());

1149

style->setWidth(Length(size.width() + resultsArrowWidth, Fixed));

1150

style->setHeight(Length(size.height(), Fixed));

1151

}

1152

1153

bool RenderThemeSafari::paintSearchFieldResultsButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect&)

1154

{

1155

ASSERT(SafariThemeLibrary());

1156

1157

Node* input = o->node()->shadowHost();

1158

if (!input)

1159

input = o->node();

1160

RenderObject* renderer = input->renderer();

1161

ASSERT(renderer);

1162

1163

IntRect searchRect = renderer->absoluteBoundingBoxRectIgnoringTransforms();

1164

1165

paintThemePart(SafariTheme::SearchFieldResultsButtonPart, paintInfo.context->platformContext(), searchRect, controlSizeFromRect(searchRect, searchFieldSizes()), determineState(o));

1166

return false;

1167

}

1168

#if ENABLE(VIDEO)

1169

bool RenderThemeSafari::paintMediaFullscreenButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

1170

{

1171

return RenderMediaControls::paintMediaControlsPart(MediaEnterFullscreenButton, o, paintInfo, r);

1172

}

1173

1174

bool RenderThemeSafari::paintMediaMuteButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

1175

{

1176

return RenderMediaControls::paintMediaControlsPart(MediaMuteButton, o, paintInfo, r);

1177

}

1178

1179

bool RenderThemeSafari::paintMediaPlayButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

1180

{

1181

return RenderMediaControls::paintMediaControlsPart(MediaPlayButton, o, paintInfo, r);

1182

}

1183

1184

bool RenderThemeSafari::paintMediaSeekBackButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

1185

{

1186

return RenderMediaControls::paintMediaControlsPart(MediaSeekBackButton, o, paintInfo, r);

1187

}

1188

1189

bool RenderThemeSafari::paintMediaSeekForwardButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

1190

{

1191

return RenderMediaControls::paintMediaControlsPart(MediaSeekForwardButton, o, paintInfo, r);

1192

}

1193

1194

bool RenderThemeSafari::paintMediaSliderTrack(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

1195

{

1196

return RenderMediaControls::paintMediaControlsPart(MediaSlider, o, paintInfo, r);

1197

}

1198

1199

bool RenderThemeSafari::paintMediaSliderThumb(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)

1200

{

1201

return RenderMediaControls::paintMediaControlsPart(MediaSliderThumb, o, paintInfo, r);

1202

}

1203

#endif

1204

1205

} // namespace WebCore

1206

1207

#endif // #if USE(SAFARI_THEME)

Older »