~hikiko/nux/arb-srgba-shader

m_ContentOffsetX = -((m_nLongestLine*m_nFontWidth) > m_ViewWidth - LeftMarginWidth() ? (m_nLongestLine*m_nFontWidth) - m_ViewWidth + LeftMarginWidth() : 0);

707

m_nHScrollPos = Abs(m_ContentOffsetX/m_nFontWidth) + 1;

708

}

709

else

710

{

711

m_nHScrollPos = Abs((m_ContentOffsetX)/m_nFontWidth);

712

}

713

714

//nuxDebugMsg(TEXT("HScrollPos = %d"), m_nHScrollPos);

715

hscrollbar->SetContentOffset(m_ContentOffsetX, m_ContentOffsetY);

716

}

717

hscrollbar->NeedRedraw();

718

RepositionCaret();

719

NeedRedraw();

720

}

721

722

void TextView::ScrollUp(float stepy, int mousedy)

723

{

724

{

725

m_ContentOffsetY += stepy * (float)mousedy;

726

if(m_ContentOffsetY > 0)

727

{

728

m_nVScrollPos = 0;

729

m_ContentOffsetY = 0;

730

}

731

else

732

{

733

m_nVScrollPos = Abs(m_ContentOffsetY / m_nLineHeight);

734

}

735

736

//nuxDebugMsg(TEXT("VScrollPos = %d"), m_nVScrollPos);

737

vscrollbar->SetContentOffset(m_ContentOffsetX, m_ContentOffsetY);

738

}

739

vscrollbar->NeedRedraw();

740

RepositionCaret();

741

NeedRedraw();

742

}

743

744

void TextView::ScrollDown(float stepy, int mousedy)

745

{

746

{

747

m_ContentOffsetY -= (float)stepy * (float)mousedy;

748

if((m_ViewY + m_ContentOffsetY + (m_nLineHeight*m_nLineCount) < m_ViewY + m_ViewHeight) && (m_ContentOffsetY<0))

749

{

750

m_ContentOffsetY = -((m_nLineHeight*m_nLineCount) > m_ViewHeight ? (m_nLineHeight*m_nLineCount) - m_ViewHeight : 0);

751

m_nVScrollPos = Abs(m_ContentOffsetY / m_nLineHeight);

752

}

753

else

754

{

755

m_nVScrollPos = Abs(m_ContentOffsetY / m_nLineHeight);

756

}

757

758

//nuxDebugMsg(TEXT("VScrollPos = %d"), m_nVScrollPos);

759

vscrollbar->SetContentOffset(m_ContentOffsetX, m_ContentOffsetY);

760

}

761

vscrollbar->NeedRedraw();

762

RepositionCaret();

763

NeedRedraw();

764

}

765

766

void TextView::RecvMouseWheel(int x, int y, int delta, t_u32 button_flags, t_u32 key_flags)

767

{

768

m_MouseWheelAcc += delta;

769

int scrollunit = m_MouseWheelAcc / INL_WIN32_MOUSEWHEEL_DELTA;

770

m_MouseWheelAcc = m_MouseWheelAcc % INL_WIN32_MOUSEWHEEL_DELTA;

771

772

if(scrollunit > 0)

773

{

774

// m_nVScrollPos--;

775

if(m_nVScrollPos > 0)

776

{

777

m_ContentOffsetY += scrollunit* m_nLineHeight;

778

if(m_ContentOffsetY > 0)

779

m_ContentOffsetY = 0;

780

781

SetupScrollbars();

782

vscrollbar->NeedRedraw();

783

RepositionCaret();

784

NeedRedraw();

785

}

786

}

787

if(scrollunit < 0)

788

{

789

// m_nVScrollPos++;

790

if(m_nVScrollPos < m_nLineCount)

791

{

792

m_ContentOffsetY += scrollunit* m_nLineHeight;

793

if(m_ContentOffsetY < -m_nLineCount*m_nLineHeight)

794

m_ContentOffsetY = -m_nLineCount*m_nLineHeight;

795

796

}

797

798

SetupScrollbars();

799

vscrollbar->NeedRedraw();

800

RepositionCaret();

801

NeedRedraw();

802

}

803

}

804

805

void TextView::RecvKeyEvent(

806

GraphicsContext& GfxContext , /*Graphics Context for text operation*/

807

t_u32 eventType , /*event type*/

808

t_u32 keysym , /*event keysym*/

809

t_u32 state , /*event state*/

810

const char* character , /*character*/

811

bool isRepeated , /*true if the key is repeated more than once*/

812

unsigned short keyCount /*key repeat count*/

813

)

814

{

815

if(keyCount && ((keysym == INL_VK_PAGE_UP) || (keysym == INL_KP_PAGE_UP)))

816

{

817

m_ContentOffsetY += m_nWindowLines* m_nLineHeight;

818

if(m_ContentOffsetY > 0)

819

m_ContentOffsetY = 0;

820

821

SetupScrollbars();

822

vscrollbar->NeedRedraw();

823

RepositionCaret();

824

NeedRedraw();

825

}

826

if(keyCount && ((keysym == INL_VK_PAGE_DOWN) || (keysym == INL_KP_PAGE_DOWN)))

827

{

828

m_ContentOffsetY -= m_nWindowLines* m_nLineHeight;

829

if(m_ContentOffsetY < -m_nLineCount*m_nLineHeight)

830

m_ContentOffsetY = -m_nLineCount*m_nLineHeight;

831

832

SetupScrollbars();

833

vscrollbar->NeedRedraw();

834

RepositionCaret();

835

NeedRedraw();

836

}

837

}

838

839

void TextView::RecvStartFocus()

840

{

841

RepositionCaret();

842

m_HasFocus = true;

843

StartBlinkCursor(true);

844

NeedRedraw();

845

}

846

847

void TextView::RecvEndFocus()

848

{

849

// if we are making a selection when we lost focus then

850

// stop the selection logic

851

if(m_nSelectionMode != SEL_NONE)

852

{

853

OnLButtonUp(0, 0, 0, 0);

854

}

855

m_HasFocus = false;

856

StopBlinkCursor(false);

857

NeedRedraw();

858

}

859

860

bool TextView::IsKeyPressed(t_u32 virtualkey)

861

{

862

return GetThreadGLWindow()->GetCurrentEvent().GetVirtualKeyState(virtualkey);

863

}

864

865

void TextView::BlinkCursorTimerInterrupt(void* v)

866

{

867

GetThreadTimer().RemoveTimerHandler(m_BlinkTimerHandler);

868

m_BlinkTimerHandler = GetThreadTimer().AddTimerHandler(500, m_BlinkTimerFunctor, this);

869

BlinkCursor = !BlinkCursor;

870

AddDirtyLine(m_nCurrentLine);

871

NeedRedraw();

872

}

873

874

void TextView::StopBlinkCursor(bool BlinkState)

875

{

876

GetThreadTimer().RemoveTimerHandler(m_BlinkTimerHandler);

877

m_BlinkTimerHandler = 0;

878

BlinkCursor = BlinkState;

879

AddDirtyLine(m_nCurrentLine);

880

NeedRedraw();

881

}

882

883

void TextView::StartBlinkCursor(bool BlinkState)

884

{

885

m_BlinkTimerHandler = GetThreadTimer().AddTimerHandler(500, m_BlinkTimerFunctor, this);

886

BlinkCursor = BlinkState;

887

AddDirtyLine(m_nCurrentLine);

888

NeedRedraw();

889

}

890

891

NAMESPACE_END_GUI

#include "Nux.h"

#include "TextView.h"

#include "TextViewInternal.h"

#include "racursor.h"

#include "HScrollBar.h"

#include "VScrollBar.h"

#include "Layout.h"

#include "HLayout.h"

#include "VLayout.h"

#include "Button.h"

#include "TimerProc.h"

NAMESPACE_BEGIN_GUI

// Constructor for TextView class

TextView::TextView(HWND hwnd)

: m_BlinkTimerFunctor(0)

, m_BlinkTimerHandler(0)

, m_HasFocus(true)

{

m_TextFontRenderer = new FontRenderer(*GetThreadGraphicsContext());

m_VBSize0 = 256*1024;

m_VBSize1 = 256*1024;

m_TextVertexBuffer0.resize(m_VBSize0);

m_TextVertexBuffer1.resize(m_VBSize1);

m_ColorQuadBuffer0.resize(m_VBSize0);

m_ColorQuadBuffer1.resize(m_VBSize1);

m_NumVBQuad0 = 0;

m_NumVBQuad1 = 0;

m_NumVBColorQuad0 = 0;

m_NumVBColorQuad1 = 0;

b_RenderToVertexBuffer = false;

m_ShaderProg = GetThreadGLDeviceFactory()->CreateShaderProgram();

m_ShaderProg->LoadIShaderFile(INL_FINDRESOURCELOCATION(TEXT("Data/Shaders/TextViewShader.glsl")));

m_ShaderProg->Link();

m_CgColor = m_ShaderProg->GetAttributeLocation(TEXT("iColor"));

m_CgPosition = m_ShaderProg->GetAttributeLocation(TEXT("iPosition"));

m_CgTexUV = m_ShaderProg->GetAttributeLocation(TEXT("iTexUV"));

m_CgFontTexture = m_ShaderProg->GetUniformLocationARB(TEXT("FontTexture"));

m_ViewProjectionMatrix0 = m_ShaderProg->GetUniformLocationARB(TEXT("ViewProjectionMatrix"));

m_ColorQuadShaderProg = GetThreadGLDeviceFactory()->CreateShaderProgram();

m_ColorQuadShaderProg->LoadIShaderFile(INL_FINDRESOURCELOCATION(TEXT("Shaders//TextViewColorQuadShader.glsl")));

m_ColorQuadShaderProg->Link();

m_CgQuadPosition = m_ColorQuadShaderProg->GetAttributeLocation(TEXT("iPosition"));

m_CgQuadColor = m_ColorQuadShaderProg->GetAttributeLocation(TEXT("iColor"));

m_ViewProjectionMatrix1 = m_ColorQuadShaderProg->GetUniformLocationARB(TEXT("ViewProjectionMatrix"));

m_hWnd = hwnd;

m_MouseWheelAcc = 0;

// Font-related data

m_nNumFonts = 1;

m_nHeightAbove = 0;

m_nHeightBelow = 0;

// File-related data

m_nLineCount = 0;

m_nLongestLine = 0;

// Scrollbar related data

m_nVScrollPos = 0;

m_nHScrollPos = 0;

m_nVScrollMax = 0;

m_nHScrollMax = 0;

// Display-related data

100

m_nTabWidthChars = 4;

101

m_uStyleFlags = 0;

102

m_nCaretWidth = 0;

103

m_nLongLineLimit = 80;

104

m_nLineInfoCount = 0;

105

m_nCRLFMode = TXL_ALL;

106

107

m_nCaretWidth = 1; // texttodo: SystemParametersInfo(SPI_GETCARETWIDTH, 0, &m_nCaretWidth, 0);

108

109

if(m_nCaretWidth == 0)

110

m_nCaretWidth = 2;

111

112

// Default display colours

113

m_rgbColourList[TXC_FOREGROUND] = 0xFFFFFFFF; // SYSCOL(COLOR_WINDOWTEXT);

114

m_rgbColourList[TXC_BACKGROUND] = 0xFF4D4D4D; // SYSCOL(COLOR_WINDOW);

115

m_rgbColourList[TXC_HIGHLIGHTTEXT] = 0xFF000000; // SYSCOL(COLOR_HIGHLIGHTTEXT);

116

m_rgbColourList[TXC_HIGHLIGHT] = 0xFFbebebe; // SYSCOL(COLOR_HIGHLIGHT);

117

m_rgbColourList[TXC_HIGHLIGHTTEXT2] = 0xFFf4f4f4; // SYSCOL(COLOR_INACTIVECAPTIONTEXT);

118

m_rgbColourList[TXC_HIGHLIGHT2] = 0xFF747474; // SYSCOL(COLOR_INACTIVECAPTION);

119

m_rgbColourList[TXC_SELMARGIN1] = 0xFFe2e2e2; // SYSCOL(COLOR_3DFACE);

120

m_rgbColourList[TXC_SELMARGIN2] = 0xFFffffff; // SYSCOL(COLOR_3DHIGHLIGHT);

121

m_rgbColourList[TXC_LINENUMBERTEXT] = 0xFFb4b4b4; // SYSCOL(COLOR_3DSHADOW);

122

m_rgbColourList[TXC_LINENUMBER] = 0xFFe2e2e2; // SYSCOL(COLOR_3DFACE);

123

m_rgbColourList[TXC_LONGLINETEXT] = 0xFFb4b4b4; // SYSCOL(COLOR_3DSHADOW);

124

m_rgbColourList[TXC_LONGLINE] = 0xFFe2e2e2; // SYSCOL(COLOR_3DFACE);

125

m_rgbColourList[TXC_CURRENTLINETEXT] = 0xFF000000; // SYSCOL(COLOR_WINDOWTEXT);

126

m_rgbColourList[TXC_CURRENTLINE] = 0xFFfff0e6; // RGB(230,240,255);

127

128

// Runtime data

129

m_nSelectionMode = SEL_NONE;

130

m_nScrollTimer = 0;

131

m_fHideCaret = false;

132

m_fTransparent = true;

133

m_hImageList = 0;

134

135

m_nSelectionStart = 0;

136

m_nSelectionEnd = 0;

137

m_nCursorOffset = 0;

138

m_nCurrentLine = 0;

139

m_nPreviousLine = 0;

140

141

m_CharacterAtCursor = 0;

142

m_CursorCharacterPosition = 0;

143

144

m_nLinenoWidth = 0;

145

m_nCaretPosX = 0;

146

m_nAnchorPosX = 0;

147

148

m_RedrawCaret = true;

149

150

m_pTextDoc = new TextDocument();

151

152

m_hMarginCursor = CreateCursor(GetModuleHandle(0), 21, 5, 32, 32, XORMask, ANDMask);

153

154

155

// The TextView state must be fully initialized before we

156

// start calling member-functions

157

158

159

hscrollbar->OnScrollLeft.connect( sigc::mem_fun(this, &TextView::ScrollLeft));

160

hscrollbar->OnScrollRight.connect( sigc::mem_fun(this, &TextView::ScrollRight));

161

vscrollbar->OnScrollUp.connect( sigc::mem_fun(this, &TextView::ScrollUp));

162

vscrollbar->OnScrollDown.connect( sigc::mem_fun(this, &TextView::ScrollDown));

163

164

OnMouseDown.connect(sigc::mem_fun(this, &TextView::OnLButtonDown));

165

OnMouseUp.connect(sigc::mem_fun(this, &TextView::OnLButtonUp));

166

OnMouseMove.connect(sigc::mem_fun(this, &TextView::RecvMouseMove));

167

OnMouseDrag.connect(sigc::mem_fun(this, &TextView::RecvMouseMove));

168

OnMouseEnter.connect(sigc::mem_fun(this, &TextView::RecvMouseEnter));

169

OnMouseLeave.connect(sigc::mem_fun(this, &TextView::RecvMouseLeave));

170

171

OnMouseWheel.connect(sigc::mem_fun(this, &TextView::RecvMouseWheel));

172

OnKeyEvent.connect(sigc::mem_fun(this, &TextView::RecvKeyEvent));

173

174

OnStartFocus.connect(sigc::mem_fun(this, &TextView::RecvStartFocus));

175

OnEndFocus.connect(sigc::mem_fun(this, &TextView::RecvEndFocus));

176

177

MouseAutoScrollTimer = new TimerFunctor;

178

MouseAutoScrollTimer->OnTimerExpired.connect(sigc::mem_fun(this, &TextView::RecvTimer));

179

MouseAutoScrollHandle = 0;

180

181

SetTextColor(Color(m_rgbColourList[TXC_FOREGROUND]));

182

SetTextBkColor(Color(m_rgbColourList[TXC_BACKGROUND]));

183

184

SetFont();

185

RecalcLineHeight();

186

OpenFile(TEXT("C:\\Development\\Inalogic\\DIGITAL.txt"));

187

SetStyle(0, TXS_SELMARGIN);

188

SetStyle(0, TXS_LINENUMBERS);

189

190

m_BlinkTimerFunctor = new TimerFunctor();

191

m_BlinkTimerFunctor->OnTimerExpired.connect(sigc::mem_fun(this, &TextView::BlinkCursorTimerInterrupt));

192

}

193

194

195

// Destructor for TextView class

196

197

TextView::~TextView()

198

{

199

if(m_pTextDoc)

200

delete m_pTextDoc;

201

202

DestroyCursor(m_hMarginCursor);

203

}

204

205

206

void TextView::SetTextBkColor(const Color& color)

207

{

208

m_TextBkColor = color;

209

}

210

211

const Color& TextView::GetTextBkColor()

212

{

213

return m_TextBkColor;

214

}

215

216

217

VOID TextView::UpdateMetrics()

218

{

219

OnSize(0, m_ViewWidth, m_ViewHeight);

220

RefreshWindow();

221

222

RepositionCaret();

223

}

224

225

LONG TextView::OnSetFocus(HWND hwndOld)

226

{

227

return 0;

228

}

229

230

LONG TextView::OnKillFocus(HWND hwndNew)

231

{

232

return 0;

233

}

234

235

t_u32 TextView::SetStyle(t_u32 uMask, t_u32 uStyles)

236

{

237

t_u32 oldstyle = m_uStyleFlags;

238

239

m_uStyleFlags = (m_uStyleFlags & ~uMask) | uStyles;

240

241

// update display here

242

UpdateMetrics();

243

RefreshWindow();

244

245

return oldstyle;

246

}

247

248

t_u32 TextView::SetVar(t_u32 nVar, t_u32 nValue)

249

{

250

return 0;//oldval;

251

}

252

253

t_u32 TextView::GetVar(t_u32 nVar)

254

{

255

return 0;

256

}

257

258

t_u32 TextView::GetStyleMask(t_u32 uMask)

259

{

260

return m_uStyleFlags & uMask;

261

}

262

263

bool TextView::CheckStyle(t_u32 uMask)

264

{

265

return (m_uStyleFlags & uMask) ? true : false;

266

}

267

268

int TextView::SetCaretWidth(int nWidth)

269

{

270

int oldwidth = m_nCaretWidth;

271

m_nCaretWidth = nWidth;

272

273

return oldwidth;

274

}

275

276

BOOL TextView::SetImageList(HIMAGELIST hImgList)

277

{

278

m_hImageList = hImgList;

279

return TRUE;

280

}

281

282

LONG TextView::SetLongLine(int nLength)

283

{

284

int oldlen = m_nLongLineLimit;

285

m_nLongLineLimit = nLength;

286

return oldlen;

287

}

288

289

int CompareLineInfo(LINEINFO *elem1, LINEINFO *elem2)

290

{

291

if(elem1->nLineNo < elem2->nLineNo)

292

return -1;

293

if(elem1->nLineNo > elem2->nLineNo)

294

return 1;

295

else

296

return 0;

297

}

298

299

int TextView::SetLineImage(t_u32 nLineNo, t_u32 nImageIdx)

300

{

301

LINEINFO *linfo = GetLineInfo(nLineNo);

302

303

// if already a line with an image

304

if(linfo)

305

{

306

linfo->nImageIdx = nImageIdx;

307

}

308

else

309

{

310

linfo = &m_LineInfo[m_nLineInfoCount++];

311

linfo->nLineNo = nLineNo;

312

linfo->nImageIdx = nImageIdx;

313

314

// sort the array

315

qsort(

316

m_LineInfo,

317

m_nLineInfoCount,

318

sizeof(LINEINFO),

319

(COMPAREPROC)CompareLineInfo

320

);

321

322

}

323

return 0;

324

}

325

326

LINEINFO* TextView::GetLineInfo(t_u32 nLineNo)

327

{

328

LINEINFO key = { nLineNo, 0 };

329

330

// perform the binary search

331

return (LINEINFO *) bsearch(

332

&key,

333

m_LineInfo,

334

m_nLineInfoCount,

335

sizeof(LINEINFO),

336

(COMPAREPROC)CompareLineInfo

337

);

338

}

339

340

341

342

// Public memberfunction

343

344

LONG WINAPI TextView::WndProc(UINT msg, WPARAM wParam, LPARAM lParam)

345

{

346

switch(msg)

347

{

348

case WM_SIZE:

349

return OnSize(wParam, LOWORD(lParam), HIWORD(lParam));

350

351

case WM_VSCROLL:

352

return OnVScroll(LOWORD(wParam), HIWORD(wParam));

353

354

case WM_HSCROLL:

355

return OnHScroll(LOWORD(wParam), HIWORD(wParam));

356

357

case WM_MOUSEACTIVATE:

358

return OnMouseActivate((HWND)wParam, LOWORD(lParam), HIWORD(lParam));

359

360

case WM_MOUSEWHEEL:

361

return OnMouseWheelFunc((short)HIWORD(wParam));

362

363

case WM_SETFOCUS:

364

return OnSetFocus((HWND)wParam);

365

366

case WM_KILLFOCUS:

367

return OnKillFocus((HWND)wParam);

368

369

case WM_SETCURSOR:

370

if(LOWORD(lParam) == HTCLIENT)

371

return TRUE;

372

else

373

break;

374

375

case TXM_OPENFILE:

376

return OpenFile((TCHAR *)lParam);

377

378

case TXM_CLEAR:

379

return ClearFile();

380

default:

381

break;

382

}

383

384

return DefWindowProc(m_hWnd, msg, wParam, lParam);

385

}

386

387

long TextView::ProcessEvent(IEvent &ievent, long TraverseInfo, long ProcessEventInfo)

388

{

389

long ret = TraverseInfo;

390

391

ret = vscrollbar->ProcessEvent(ievent, ret, ProcessEventInfo);

392

ret = hscrollbar->ProcessEvent(ievent, ret, ProcessEventInfo);

393

394

ret = GetCompositionLayout()->ProcessEvent(ievent, ret, ProcessEventInfo);

395

396

// PostProcessEvent2 must always have its last parameter set to 0

397

// because the m_BackgroundArea is the real physical limit of the window.

398

// So the previous test about IsPointInside do not prevail over m_BackgroundArea

399

// testing the event by itself.

400

ret = PostProcessEvent2(ievent, ret, 0);

401

402

if(ievent.e_event == INL_WINDOW_ENTER_FOCUS)

403

{

404

m_HasFocus = true;

405

StopBlinkCursor(false);

406

StartBlinkCursor(false);

407

}

408

if(ievent.e_event == INL_WINDOW_EXIT_FOCUS)

409

{

410

m_HasFocus = false;

411

StopBlinkCursor(false);

412

}

413

414

return ret;

415

}

416

417

void TextView::Draw(GraphicsContext& GfxContext, bool force_draw)

418

{

419

GfxContext.PushClippingRectangle(GetGeometry());

420

421

b_RenderToVertexBuffer = true;

422

m_NumVBQuad0 = 0;

423

m_NumVBQuad1 = 0;

424

m_NumVBColorQuad0 = 0;

425

m_NumVBColorQuad1 = 0;

426

427

OnPaint(GfxContext);

428

429

if(b_RenderToVertexBuffer)

430

{

431

GetThreadGraphicsContext()->GetRenderStates().SetBlend(TRUE, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

432

GetThreadGraphicsContext()->GetRenderStates().SetColorMask(TRUE, TRUE, TRUE, FALSE); // Do not write the alpha of characters

433

434

GfxContext.EnableTextureMode(GL_TEXTURE0, GL_TEXTURE_RECTANGLE_ARB);

435

TRefGL< NGLRectangleTexture > glTexture = GfxContext.ResourceCache.GetCachedResource(m_TextFont->TextureArray[0]);

436

GetThreadGraphicsContext()->SetTexture(GL_TEXTURE0, glTexture->m_Texture);

437

438

/////////////////////////////////////////////////////////////////////////////////////////////////////

439

m_ColorQuadShaderProg->Begin();

440

441

Matrix4 Quadmat = GetThreadGraphicsContext()->GetModelViewProjectionMatrix();

442

if(m_ViewProjectionMatrix1 != -1)

443

m_ColorQuadShaderProg->SetUniformLocMatrix4fv(m_ViewProjectionMatrix1, 1, false, (float*)&Quadmat);

444

445

// Draw Line Number quad background

446

{

447

Geometry rect = GetTextAreaGeometry();

448

rect.SetWidth(LeftMarginWidth());

449

GfxContext.PushClippingRectangle(rect);

450

if(m_CgQuadPosition != -1)

451

{

452

CHECKGL( glEnableVertexAttribArrayARB(m_CgQuadPosition) );

453

CHECKGL( glVertexAttribPointerARB(m_CgQuadPosition, 4, GL_FLOAT, GL_FALSE, 32, &m_ColorQuadBuffer1[0]) );

454

}

455

if(m_CgQuadColor != -1)

456

{

457

CHECKGL( glEnableVertexAttribArrayARB(m_CgQuadColor) );

458

CHECKGL( glVertexAttribPointerARB(m_CgQuadColor, 4, GL_FLOAT, GL_FALSE, 32, &m_ColorQuadBuffer1[0]+4) );

459

}

460

461

CHECKGL( glDrawArrays( GL_QUADS, 0, m_NumVBColorQuad1*4 ) );

462

463

if(m_CgQuadPosition != -1)

464

CHECKGL( glDisableVertexAttribArrayARB(m_CgQuadPosition) );

465

if(m_CgQuadColor != -1)

466

CHECKGL( glDisableVertexAttribArrayARB(m_CgQuadColor) );

467

GfxContext.PopClippingRectangle();

468

}

469

470

// Draw Text quad background

471

{

472

Geometry rect = GetTextAreaGeometry();

473

rect.OffsetPosition(LeftMarginWidth(), 0);

474

rect.OffsetSize(-LeftMarginWidth(), 0);

475

GfxContext.PushClippingRectangle(rect);

476

if(m_CgQuadPosition != -1)

477

{

478

CHECKGL( glEnableVertexAttribArrayARB(m_CgQuadPosition) );

479

CHECKGL( glVertexAttribPointerARB(m_CgQuadPosition, 4, GL_FLOAT, GL_FALSE, 32, &m_ColorQuadBuffer0[0]) );

480

}

481

if(m_CgQuadColor != -1)

482

{

483

CHECKGL( glEnableVertexAttribArrayARB(m_CgQuadColor) );

484

CHECKGL( glVertexAttribPointerARB(m_CgQuadColor, 4, GL_FLOAT, GL_FALSE, 32, &m_ColorQuadBuffer0[0]+4) );

485

}

486

487

CHECKGL( glDrawArrays( GL_QUADS, 0, m_NumVBColorQuad0*4 ) );

488

489

if(m_CgQuadPosition != -1)

490

CHECKGL( glDisableVertexAttribArrayARB(m_CgQuadPosition) );

491

if(m_CgQuadColor != -1)

492

CHECKGL( glDisableVertexAttribArrayARB(m_CgQuadColor) );

493

GfxContext.PopClippingRectangle();

494

}

495

m_ColorQuadShaderProg->End();

496

497

498

m_ShaderProg->Begin();

499

500

Quadmat = GetThreadGraphicsContext()->GetModelViewProjectionMatrix();

501

if(m_ViewProjectionMatrix0 != -1)

502

m_ShaderProg->SetUniformLocMatrix4fv(m_ViewProjectionMatrix0, 1, false, (float*)&Quadmat);

503

504

if(m_CgFontTexture != -1)

505

{

506

CHECKGL( glUniform1iARB(m_CgFontTexture, 0) );

507

}

508

509

// Draw Line Number

510

{

511

Geometry rect = GetTextAreaGeometry();

512

rect.SetWidth(LeftMarginWidth());

513

GfxContext.PushClippingRectangle(rect);

514

515

if(m_CgPosition != -1)

516

{

517

CHECKGL( glEnableVertexAttribArrayARB(m_CgPosition) );

518

CHECKGL( glVertexAttribPointerARB(m_CgPosition, 4, GL_FLOAT, GL_FALSE, 48, &m_TextVertexBuffer1[0]) );

519

}

520

521

if(m_CgTexUV != -1)

522

{

523

CHECKGL( glEnableVertexAttribArrayARB(m_CgTexUV) );

524

CHECKGL( glVertexAttribPointerARB(m_CgTexUV, 4, GL_FLOAT, GL_FALSE, 48, &m_TextVertexBuffer1[0]+4) );

525

}

526

527

if(m_CgColor != -1)

528

{

529

CHECKGL( glEnableVertexAttribArrayARB(m_CgColor) );

530

CHECKGL( glVertexAttribPointerARB(m_CgColor, 4, GL_FLOAT, GL_FALSE, 48, &m_TextVertexBuffer1[0]+8) );

531

}

532

533

CHECKGL( glDrawArrays( GL_QUADS, 0, m_NumVBQuad1*4 ) );

534

535

if(m_CgPosition != -1)

536

CHECKGL( glDisableVertexAttribArrayARB(m_CgPosition) );

537

if(m_CgTexUV != -1)

538

CHECKGL( glDisableVertexAttribArrayARB(m_CgTexUV) );

539

if(m_CgColor != -1)

540

CHECKGL( glDisableVertexAttribArrayARB(m_CgColor) );

541

GfxContext.PopClippingRectangle();

542

}

543

544

// Draw Text

545

{

546

Geometry rect = GetTextAreaGeometry();

547

rect.OffsetPosition(LeftMarginWidth(), 0);

548

rect.OffsetSize(-LeftMarginWidth(), 0);

549

GfxContext.PushClippingRectangle(rect);

550

551

if(m_CgPosition != -1)

552

{

553

CHECKGL( glEnableVertexAttribArrayARB(m_CgPosition) );

554

CHECKGL( glVertexAttribPointerARB(m_CgPosition, 4, GL_FLOAT, GL_FALSE, 48, &m_TextVertexBuffer0[0]) );

555

}

556

557

if(m_CgTexUV != -1)

558

{

559

CHECKGL( glEnableVertexAttribArrayARB(m_CgTexUV) );

560

CHECKGL( glVertexAttribPointerARB(m_CgTexUV, 4, GL_FLOAT, GL_FALSE, 48, &m_TextVertexBuffer0[0]+4) );

561

}

562

563

if(m_CgColor != -1)

564

{

565

CHECKGL( glEnableVertexAttribArrayARB(m_CgColor) );

566

CHECKGL( glVertexAttribPointerARB(m_CgColor, 4, GL_FLOAT, GL_FALSE, 48, &m_TextVertexBuffer0[0]+8) );

567

}

568

569

CHECKGL( glDrawArrays( GL_QUADS, 0, m_NumVBQuad0*4 ) );

570

571

if(m_CgPosition != -1)

572

CHECKGL( glDisableVertexAttribArrayARB(m_CgPosition) );

573

if(m_CgTexUV != -1)

574

CHECKGL( glDisableVertexAttribArrayARB(m_CgTexUV) );

575

if(m_CgColor != -1)

576

CHECKGL( glDisableVertexAttribArrayARB(m_CgColor) );

577

578

GfxContext.PopClippingRectangle();

579

}

580

581

m_ShaderProg->End();

582

583

GetThreadGraphicsContext()->GetRenderStates().SetColorMask(TRUE, TRUE, TRUE, TRUE);

584

GetThreadGraphicsContext()->GetRenderStates().SetBlend(FALSE);

585

586

CHECKGL( glDisable(GL_TEXTURE_RECTANGLE_ARB) );

587

}

588

589

b_RenderToVertexBuffer = false;

590

591

if(m_vertical_scrollbar_enable)

592

{

593

vscrollbar->ProcessDraw(GfxContext, force_draw);

594

}

595

if(m_horizontal_scrollbar_enable)

596

{

597

hscrollbar->ProcessDraw(GfxContext, force_draw);

598

}

599

600

GfxContext.PopClippingRectangle();

601

}

602

603

void TextView::DrawContent(GraphicsContext& GfxContext, bool force_draw)

604

{

605

static int n = 0;

606

if(m_vertical_scrollbar_enable)

607

{

608

vscrollbar->ProcessDraw(GfxContext, force_draw);

609

}

610

if(m_horizontal_scrollbar_enable)

611

{

612

hscrollbar->ProcessDraw(GfxContext, force_draw);

613

}

614

615

std::vector<int>::iterator it;

616

int NumDirtyLines = m_DirtyLines.size();

617

for(it = m_DirtyLines.begin(); it != m_DirtyLines.end(); it++)

618

{

619

int LineNumber = *(it);

620

OnPaintLine(GfxContext, LineNumber);

621

//nuxDebugMsg(TEXT("Paint line (%d): %d"), n, LineNumber);

622

++n;

623

}

624

625

//if(m_RedrawCaret)

626

{

627

if((!m_fHideCaret) && m_HasFocus)

628

{

629

GfxContext.PushClippingRectangle(Geometry(m_ViewX /*+ LeftMarginWidth()*/, m_ViewY, m_ViewWidth /*- LeftMarginWidth()*/, m_ViewHeight));

630

//gPainter.Draw2DLine(GfxContext, m_CaretPosition.x, m_CaretPosition.y, m_CaretPosition.x, m_CaretPosition.y + m_nLineHeight, Color(0xFFAA0000));

631

if(!BlinkCursor)

632

gPainter.Paint2DQuadColor(GfxContext, m_CaretPosition.x, m_CaretPosition.y, 2, m_nLineHeight, Color(0xFFAA0000));

633

634

GfxContext.PopClippingRectangle();

635

m_DirtyLines.clear();

636

}

637

m_RedrawCaret = false;

638

}

639

}

640

641

void TextView::PreLayoutManagement()

642

{

643

TextViewWidget::PreLayoutManagement();

644

}

645

646

long TextView::PostLayoutManagement(long LayoutResult)

647

{

648

long ret = TextViewWidget::PostLayoutManagement(LayoutResult);

649

650

UpdateMetrics();

651

UpdateMarginWidth();

652

return ret;

653

}

654

655

void TextView::PositionChildLayout(float offsetX, float offsetY)

656

{

657

TextViewWidget::PositionChildLayout(offsetX, offsetY);

658

}

659

660

Geometry TextView::GetTextAreaGeometry() const

661

{

662

Geometry rect;

663

int vscrollbarwidth = 0;

664

int hscrollbarheight = 0;

665

if(m_vertical_scrollbar_enable)

666

vscrollbarwidth = vscrollbar->GetBaseWidth();

667

if(m_horizontal_scrollbar_enable)

668

hscrollbarheight = hscrollbar->GetBaseHeight();

669

670

rect = GetGeometry();

671

rect.OffsetPosition(getBorder() + GetViewContentLeftMargin(), getTopBorder() + GetViewContentTopMargin());

672

rect.OffsetSize(-(2*getBorder() + GetViewContentLeftMargin() + GetViewContentRightMargin() + vscrollbarwidth),

673

-(getTopBorder() + getBorder() + GetViewContentTopMargin() + GetViewContentBottomMargin() + hscrollbarheight));

674

675

return rect;

676

}

677

678

void TextView::ScrollLeft(float stepx, int mousedx)

679

{

680

{

681

m_ContentOffsetX += (float)stepx * (float)mousedx;;

682

if(m_ContentOffsetX > 0)

683

{

684

m_nHScrollPos = 0;

685

m_ContentOffsetX = 0;

686

}

687

else

688

{

689

m_nHScrollPos = Abs(m_ContentOffsetX/m_nFontWidth);

690

}

691

692

//nuxDebugMsg(TEXT("HScrollPos = %d"), m_nHScrollPos);

693

hscrollbar->SetContentOffset(m_ContentOffsetX, m_ContentOffsetY);

694

}

695

hscrollbar->NeedRedraw();

696

RepositionCaret();

697

NeedRedraw();

698

}

699

700

void TextView::ScrollRight(float stepx, int mousedx)

701

{

702

{

703

m_ContentOffsetX -= (float)stepx * (float)mousedx;

704

if((m_ViewX + m_ContentOffsetX + (m_nLongestLine*m_nFontWidth) < m_ViewX - LeftMarginWidth() + m_ViewWidth) && (m_ContentOffsetX < 0))

705

{

706

m_ContentOffsetX = -((m_nLongestLine*m_nFontWidth) > m_ViewWidth - LeftMarginWidth() ? (m_nLongestLine*m_nFontWidth) - m_ViewWidth + LeftMarginWidth() : 0);

707

m_nHScrollPos = Abs(m_ContentOffsetX/m_nFontWidth) + 1;

708

}

709

else

710

{

711

m_nHScrollPos = Abs((m_ContentOffsetX)/m_nFontWidth);

712

}

713

714

//nuxDebugMsg(TEXT("HScrollPos = %d"), m_nHScrollPos);

715

hscrollbar->SetContentOffset(m_ContentOffsetX, m_ContentOffsetY);

716

}

717

hscrollbar->NeedRedraw();

718

RepositionCaret();

719

NeedRedraw();

720

}

721

722

void TextView::ScrollUp(float stepy, int mousedy)

723

{

724

{

725

m_ContentOffsetY += stepy * (float)mousedy;

726

if(m_ContentOffsetY > 0)

727

{

728

m_nVScrollPos = 0;

729

m_ContentOffsetY = 0;

730

}

731

else

732

{

733

m_nVScrollPos = Abs(m_ContentOffsetY / m_nLineHeight);

734

}

735

736

//nuxDebugMsg(TEXT("VScrollPos = %d"), m_nVScrollPos);

737

vscrollbar->SetContentOffset(m_ContentOffsetX, m_ContentOffsetY);

738

}

739

vscrollbar->NeedRedraw();

740

RepositionCaret();

741

NeedRedraw();

742

}

743

744

void TextView::ScrollDown(float stepy, int mousedy)

745

{

746

{

747

m_ContentOffsetY -= (float)stepy * (float)mousedy;

748

if((m_ViewY + m_ContentOffsetY + (m_nLineHeight*m_nLineCount) < m_ViewY + m_ViewHeight) && (m_ContentOffsetY<0))

749

{

750

m_ContentOffsetY = -((m_nLineHeight*m_nLineCount) > m_ViewHeight ? (m_nLineHeight*m_nLineCount) - m_ViewHeight : 0);

751

m_nVScrollPos = Abs(m_ContentOffsetY / m_nLineHeight);

752

}

753

else

754

{

755

m_nVScrollPos = Abs(m_ContentOffsetY / m_nLineHeight);

756

}

757

758

//nuxDebugMsg(TEXT("VScrollPos = %d"), m_nVScrollPos);

759

vscrollbar->SetContentOffset(m_ContentOffsetX, m_ContentOffsetY);

760

}

761

vscrollbar->NeedRedraw();

762

RepositionCaret();

763

NeedRedraw();

764

}

765

766

void TextView::RecvMouseWheel(int x, int y, int delta, t_u32 button_flags, t_u32 key_flags)

767

{

768

m_MouseWheelAcc += delta;

769

int scrollunit = m_MouseWheelAcc / INL_WIN32_MOUSEWHEEL_DELTA;

770

m_MouseWheelAcc = m_MouseWheelAcc % INL_WIN32_MOUSEWHEEL_DELTA;

771

772

if(scrollunit > 0)

773

{

774

// m_nVScrollPos--;

775

if(m_nVScrollPos > 0)

776

{

777

m_ContentOffsetY += scrollunit* m_nLineHeight;

778

if(m_ContentOffsetY > 0)

779

m_ContentOffsetY = 0;

780

781

SetupScrollbars();

782

vscrollbar->NeedRedraw();

783

RepositionCaret();

784

NeedRedraw();

785

}

786

}

787

if(scrollunit < 0)

788

{

789

// m_nVScrollPos++;

790

if(m_nVScrollPos < m_nLineCount)

791

{

792

m_ContentOffsetY += scrollunit* m_nLineHeight;

793

if(m_ContentOffsetY < -m_nLineCount*m_nLineHeight)

794

m_ContentOffsetY = -m_nLineCount*m_nLineHeight;

795

796

}

797

798

SetupScrollbars();

799

vscrollbar->NeedRedraw();

800

RepositionCaret();

801

NeedRedraw();

802

}

803

}

804

805

void TextView::RecvKeyEvent(

806

GraphicsContext& GfxContext , /*Graphics Context for text operation*/

807

t_u32 eventType , /*event type*/

808

t_u32 keysym , /*event keysym*/

809

t_u32 state , /*event state*/

810

const char* character , /*character*/

811

bool isRepeated , /*true if the key is repeated more than once*/

812

unsigned short keyCount /*key repeat count*/

813

)

814

{

815

if(keyCount && ((keysym == INL_VK_PAGE_UP) || (keysym == INL_KP_PAGE_UP)))

816

{

817

m_ContentOffsetY += m_nWindowLines* m_nLineHeight;

818

if(m_ContentOffsetY > 0)

819

m_ContentOffsetY = 0;

820

821

SetupScrollbars();

822

vscrollbar->NeedRedraw();

823

RepositionCaret();

824

NeedRedraw();

825

}

826

if(keyCount && ((keysym == INL_VK_PAGE_DOWN) || (keysym == INL_KP_PAGE_DOWN)))

827

{

828

m_ContentOffsetY -= m_nWindowLines* m_nLineHeight;

829

if(m_ContentOffsetY < -m_nLineCount*m_nLineHeight)

830

m_ContentOffsetY = -m_nLineCount*m_nLineHeight;

831

832

SetupScrollbars();

833

vscrollbar->NeedRedraw();

834

RepositionCaret();

835

NeedRedraw();

836

}

837

}

838

839

void TextView::RecvStartFocus()

840

{

841

RepositionCaret();

842

m_HasFocus = true;

843

StartBlinkCursor(true);

844

NeedRedraw();

845

}

846

847

void TextView::RecvEndFocus()

848

{

849

// if we are making a selection when we lost focus then

850

// stop the selection logic

851

if(m_nSelectionMode != SEL_NONE)

852

{

853

OnLButtonUp(0, 0, 0, 0);

854

}

855

m_HasFocus = false;

856

StopBlinkCursor(false);

857

NeedRedraw();

858

}

859

860

bool TextView::IsKeyPressed(t_u32 virtualkey)

861

{

862

return GetThreadGLWindow()->GetCurrentEvent().GetVirtualKeyState(virtualkey);

863

}

864

865

void TextView::BlinkCursorTimerInterrupt(void* v)

866

{

867

GetThreadTimer().RemoveTimerHandler(m_BlinkTimerHandler);

868

m_BlinkTimerHandler = GetThreadTimer().AddTimerHandler(500, m_BlinkTimerFunctor, this);

869

BlinkCursor = !BlinkCursor;

870

AddDirtyLine(m_nCurrentLine);

871

NeedRedraw();

872

}

873

874

void TextView::StopBlinkCursor(bool BlinkState)

875

{

876

GetThreadTimer().RemoveTimerHandler(m_BlinkTimerHandler);

877

m_BlinkTimerHandler = 0;

878

BlinkCursor = BlinkState;

879

AddDirtyLine(m_nCurrentLine);

880

NeedRedraw();

881

}

882

883

void TextView::StartBlinkCursor(bool BlinkState)

884

{

885

m_BlinkTimerHandler = GetThreadTimer().AddTimerHandler(500, m_BlinkTimerFunctor, this);

886

BlinkCursor = BlinkState;

887

AddDirtyLine(m_nCurrentLine);

888

NeedRedraw();

889

}

890

891

NAMESPACE_END_GUI

Older »