~ubuntu-branches/ubuntu/precise/kompozer/precise

aKey=(LoadString(gMainInst,IDS_PRE60_KEY,gKeyBuffer,sizeof(gKeyBuffer))) ? gKeyBuffer : "Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\netscp6.exe";

405

406

aSubkey = (LoadString(gMainInst,IDS_SUBKEY_PATH,gSubKeyBuffer,sizeof(gSubKeyBuffer))) ? gSubKeyBuffer : "Path";

407

408

gBrowserWindowName = (LoadString(gMainInst,IDS_NS_WINDOWNAME,gWinNameBuffer,sizeof(gWinNameBuffer))) ? gWinNameBuffer: "- Netstacpe 6";

409

410

aSize=Get60ModuleList(aModuleList);

411

412

break;

413

414

case eUserPath:

415

aKey = 0;

416

aSubkey= 0;

417

strcpy(gMozPath,gUserPath);

418

419

aSize=Get65ModuleList(aModuleList);

420

421

gBrowserWindowName = (LoadString(gMainInst,IDS_MOZ_WINDOWNAME,gWinNameBuffer,sizeof(gWinNameBuffer))) ? gWinNameBuffer: "- Mozilla";

422

423

break;

424

425

case eUnknownVersion:

426

break;

427

}

428

}

429

430

/*********************************************************

431

Get the path to the netscape6 browser via the registry...

432

*********************************************************/

433

bool GetMozillaRegistryInfo(eAppVersion &aVersion) {

434

435

//first we try to get the registry info based on the command line settings.

436

//if that fails, we try others.

437

438

bool found=false;

439

LONG theOpenResult = 1; //any non-zero will do to initialize this...

440

441

if ( aVersion == eUserPath) {

442

found=true;

443

}

444

445

while((ERROR_SUCCESS!=theOpenResult) && (aVersion<eUnknownVersion)) {

446

447

GetPathFromRegistry(aVersion,gRegKey,gRegSubKey,gModuleCP,gModuleCount);

448

449

CRegKey theRegKey;

450

451

if((eUserPath!=aVersion) && (gRegKey)) {

452

theOpenResult=theRegKey.Open(HKEY_LOCAL_MACHINE,gRegKey,KEY_QUERY_VALUE);

453

454

if(ERROR_SUCCESS==theOpenResult) {

455

DWORD theSize=1024;

456

457

theRegKey.QueryValue(gMozPath,gRegSubKey,&theSize);

458

459

if((ERROR_SUCCESS==theOpenResult) && (aVersion!=eUserPath)) {

460

461

theSize=1024;

462

char theCachedModuleList[1024] = {0};

463

464

theRegKey.QueryValue(theCachedModuleList,"Modules",&theSize);

465

466

if(theCachedModuleList[0]) {

467

strcpy(gMozModuleList,theCachedModuleList);

468

}

469

else {

470

theRegKey.Create(HKEY_LOCAL_MACHINE,gRegKey);

471

theRegKey.SetValue( HKEY_LOCAL_MACHINE, gRegKey, gMozModuleList, "Modules");

472

}

473

}

474

475

found=true;

476

break;

477

}

478

}

479

aVersion=eAppVersion(int(aVersion)+1);

480

481

} //while

482

483

gMozPathLen=strlen(gMozPath);

484

gModuleCP = gMozModuleList;

485

486

return found;

487

}

488

489

490

/*********************************************************

491

Extract the "next" module name from our module name list.

492

XXX The module names should come from string resources.

493

*********************************************************/

494

void GetNextModuleName(char* aName) {

495

//scan ahead to find the next ';' or the end of the string...

496

bool done=false;

497

char theChar=0;

498

499

aName[0]=0;

500

501

char *theCP=gModuleCP;

502

503

while(*theCP) {

504

theChar=*theCP;

505

if(';'==theChar)

506

break;

507

else theCP++;

508

}

509

510

if(theCP!=gModuleCP) {

511

size_t theSize=theCP-gModuleCP;

512

strncpy(aName,gModuleCP,theSize);

513

aName[theSize]=0;

514

gModuleCP=theCP;

515

while(';'==*gModuleCP)

516

gModuleCP++;

517

}

518

519

}

520

521

/****************************************************************

522

The following types are fraudulent. They're just here so

523

we can write up calls entry points in each module.

524

****************************************************************/

525

526

const int gMaxDLLCount=256;

527

const int gMaxProcCount=512;

528

static HINSTANCE gInstances[gMaxDLLCount];

529

static long* gFuncTable[gMaxDLLCount][gMaxProcCount];

530

static int gDLLCount=0;

531

static int gMaxEntryIndex=0;

532

533

534

/****************************************************************

535

This helper function is called by LoadModule. We separated this

536

stuff out so we can use the same code to load java modules

537

that aren't in the mozilla directory.

538

****************************************************************/

539

HINSTANCE LoadModuleFromPath(const char* aPath) {

540

541

HINSTANCE theInstance=gInstances[gDLLCount++]=LoadLibrary(aPath);

542

543

//we'll constrain the steprate to the range 1..20.

544

static double kPercent=(100-gEntryPercent)/100.0;

545

static const int kEntryStepRate=1+int(20*kPercent);

546

int theEntryCount=0;

547

548

if(theInstance) {

549

//let's get addresses throughout the module, skipping by the rate of kEntryStepRate.

550

for(int theEntryPoint=0;theEntryPoint<gMaxProcCount;theEntryPoint++){

551

long *entry=(long*)::GetProcAddress(theInstance,MAKEINTRESOURCE(1+(kEntryStepRate*theEntryPoint)));

552

if(entry) {

553

gFuncTable[gDLLCount-1][theEntryCount++]=entry;

554

}

555

else {

556

break;

557

}

558

}

559

if(theEntryCount>gMaxEntryIndex)

560

gMaxEntryIndex=theEntryCount; //we track the highest index we find.

561

}

562

563

return theInstance;

564

}

565

566

567

/****************************************************************

568

Call this once for each module you want to preload.

569

We use gEntryPercent to determine what percentage of entry

570

p oints to acquire (we will always get at least 1, and we'll

571

skip at most 20 entry points at a time).

572

****************************************************************/

573

HINSTANCE LoadModule(const char* aName) {

574

575

//we operate on gMozPath directly to avoid an unnecessary string copy.

576

//when we're done with this method, we reset gMozpath to it's original value for reuse.

577

578

strcat(gMozPath,aName);

579

strcat(gMozPath,".dll");

580

581

HINSTANCE theInstance = LoadModuleFromPath(gMozPath);

582

583

gMozPath[gMozPathLen]=0;

584

return theInstance;

585

}

586

587

588

BOOL CALLBACK EnumWindowsProc(HWND hwnd,LPARAM lParam ) {

589

590

char buf[256]={0};

591

if(GetWindowText(hwnd,buf,sizeof(buf))){

592

if(strstr(buf,gBrowserWindowName)) {

593

return FALSE; //stop iterating now...

594

}

595

}

596

return TRUE;

597

}

598

599

/****************************************************************

600

Call this to detect whether the browser is running.

601

We cache the result to speed up this function (by preventing

602

subsuquent searches of top level windows).

603

****************************************************************/

604

bool BrowserIsRunning() {

605

static bool gBrowserIsRunning=false;

606

607

if(!gBrowserIsRunning) {

608

if(!EnumWindows(EnumWindowsProc,0)) {

609

gBrowserIsRunning=true;

610

}

611

}

612

613

return gBrowserIsRunning;

614

}

615

616

/****************************************************************

617

This function get's called repeatedly to call on a timer,

618

and it calls GetProcAddr() to keep modules from paging.

619

620

NOTE: This method uses gFrequencyPercent to determine how much

621

work to do each time it gets called.

622

623

****************************************************************/

624

VOID CALLBACK KeepAliveTimerProc(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime ) {

625

626

//let's go see if mozilla is running.

627

//if so, then bail out without pinging modules...

628

629

if(BrowserIsRunning()) {

630

return;

631

}

632

633

static bool theTimerIsRunning=false;

634

static int theCurrentModule=0;

635

static int theCurrentProc=0;

636

637

if(!theTimerIsRunning) { //ignore other timer calls till we're done.

638

theTimerIsRunning=true;

639

640

//constrain the step to 1..gDLLCount

641

static const double kPercent=gFrequencyPercent/100.0;

642

static const int kMaxSteps=1+int(3*gDLLCount*kPercent);

643

644

int count=0;

645

646

//this version iterates the entry points in each module before moving to the next module

647

648

while(count<kMaxSteps) {

649

650

volatile long *p=(long*)gFuncTable[theCurrentModule][theCurrentProc];

651

count++;

652

if (p) {

653

if (*p && p){

654

//don't actually invoke it, just cause it to load into memory...

655

//note that modules have different number of entry points.

656

//so not all modules have an entry point at theCurrentProc index.

657

int x=10;

658

}

659

}

660

661

#define _DEPTH_FIRST

662

#ifdef _DEPTH_FIRST

663

664

if(theCurrentModule >= gDLLCount) {

665

theCurrentModule = 0;

666

theCurrentProc = (theCurrentProc>=gMaxEntryIndex) ? 0 : theCurrentProc+1;

667

}

668

else {

669

theCurrentModule++;

670

}

671

672

#else //breadth first...

673

674

if(theCurrentProc >= gMaxEntryIndex) {

675

theCurrentProc=0;

676

theCurrentModule = (theCurrentModule>=gDLLCount) ? 0 : theCurrentModule+1;

677

}

678

else {

679

theCurrentProc++;

680

}

681

682

#endif

683

684

}

685

686

theTimerIsRunning=false;

687

}

688

}

689

690

691

/****************************************************************

692

This gets called repeatedly by a windows timer, and loads

693

the modules that it gets from the modulelist (see top of this file).

694

695

This routine has been updated to account for the gModulesPercent

696

setting (1-100). We'll load modules until we cross over this

697

percentage.

698

****************************************************************/

699

VOID CALLBACK LoadModuleTimerProc(HWND hwnd, UINT uMsg, UINT idEvent,DWORD dwTime) {

700

701

static bool theTimerIsRunning=false;

702

static int gTrayIconIndex = 0;

703

704

if(!theTimerIsRunning) {

705

theTimerIsRunning=true;

706

707

//gDLLCount is the number of modules loaded so far

708

//gModuleCount is the total number of modules we know about

709

//gModulePercent is the total % of modules we're being asked to load (config setting)

710

711

double theMaxPercentToLoad=gModulePercent/100.0;

712

713

//we'll only load more modules if haven't loaded the max percentage of modules

714

//based on the configuration UI (stored in gModulePercent).

715

716

const int theModulePerCallCount = 3; // specifies how many modules to load per timer callback.

717

bool done=false;

718

719

for(int theModuleIndex=0;theModuleIndex<theModulePerCallCount;theModuleIndex++) {

720

721

SetTrayIcon(gCheckIcons[gTrayIconIndex]);

722

723

gTrayIconIndex = (gTrayIconIndex==1) ? 0 : gTrayIconIndex+1; //this toggles the preloader icon to show activity...

724

725

char theDLLName[512];

726

GetNextModuleName(theDLLName);

727

728

if(theDLLName[0]) {

729

if(gDLLCount/(gModuleCount*1.0)<=theMaxPercentToLoad) {

730

HINSTANCE theInstance=LoadModule(theDLLName);

731

}

732

else done=true;

733

}

734

else done=true;

735

736

if(done) {

737

738

//if they've asked us to preload java, then do so here...

739

if(gPreloadJava) {

740

741

char kJavaRegStr[512] = {0};

742

if(LoadString(gMainInst,IDS_JAVAREGSTR,kJavaRegStr,sizeof(kJavaRegStr))){

743

744

CRegKey theRegKey;

745

746

LONG theOpenResult=theRegKey.Open(HKEY_LOCAL_MACHINE,kJavaRegStr,KEY_QUERY_VALUE);

747

if(ERROR_SUCCESS==theOpenResult) {

748

749

char kJavaRegPath[128] = {0};

750

if(LoadString(gMainInst,IDS_JAVAREGPATH,kJavaRegPath,sizeof(kJavaRegPath))){

751

752

char thePath[1024] = {0};

753

DWORD theSize=sizeof(thePath);

754

theRegKey.QueryValue(thePath,kJavaRegPath,&theSize);

755

756

if(thePath) {

757

//here we go; let's load java and awt...

758

char theTempPath[1024]={0};

759

760

sprintf(theTempPath,"%s\\hotspot\\jvm.dll",thePath);

761