~ubuntu-branches/ubuntu/precise/boinc/precise

_("You currently are not authorized to manage the client.\n\nTo run BOINC as this user, please:\n - reinstall BOINC answering \"Yes\" to the question about\n non-administrative users\n or\n - contact your administrator to add you to the 'boinc_master'\n user group.");

327

} else {

328

strDialogMessage.Printf(

329

_("BOINC ownership or permissions are not set properly; please reinstall BOINC.\n(Error code %d)"),

330

iErrorCode

331

);

332

333

}

334

wxMessageDialog* pDlg = new wxMessageDialog(NULL, strDialogMessage, wxT("BOINC Manager"), wxOK);

335

336

pDlg->ShowModal();

337

if (pDlg)

338

pDlg->Destroy();

339

340

return false;

341

}

342

#endif // SANDBOX

343

344

345

// Enable known image types

346

wxInitAllImageHandlers();

347

348

// Enable additional file system type handlers

349

wxFileSystem::AddHandler(new wxMemoryFSHandler);

350

wxFileSystem::AddHandler(new CBOINCInternetFSHandler);

351

352

// Initialize the skin manager

353

m_pSkinManager = new CSkinManager(m_bDebugSkins);

354

wxASSERT(m_pSkinManager);

355

356

357

// Load desired manager skin

358

m_pConfig->Read(wxT("Skin"), &strDesiredSkinName, m_pSkinManager->GetDefaultSkinName());

359

m_pSkinManager->ReloadSkin(

360

m_pLocale,

361

strDesiredSkinName

362

);

363

364

365

#ifdef __WXMSW__

366

// Perform any last minute checks that should keep the manager

367

// from starting up.

368

wxString strRebootPendingFile =

369

GetRootDirectory() + wxFileName::GetPathSeparator() + wxT("RebootPending.txt");

370

371

if (wxFile::Exists(strRebootPendingFile)) {

372

wxMessageDialog dialog(

373

NULL,

374

_("A reboot is required in order for BOINC to run properly.\nPlease reboot your computer and try again."),

375

_("BOINC Manager"),

376

wxOK|wxICON_ERROR

377

);

378

379

dialog.ShowModal();

380

return false;

381

}

382

#endif

383

384

// Detect if BOINC Manager is already running, if so, bring it into the

385

// foreground and then exit.

386

if (!m_bMultipleInstancesOK) {

387

if (DetectDuplicateInstance()) {

388

return false;

389

}

390

}

391

392

// Initialize the main document

393

m_pDocument = new CMainDocument();

394

wxASSERT(m_pDocument);

395

396

m_pDocument->OnInit();

397

398

399

// Is there a condition in which the Simple GUI should not be used?

400

if (BOINC_SIMPLEGUI == m_iGUISelected) {

401

402

// Screen too small?

403

if (wxGetDisplaySize().GetHeight() < 600) {

404

m_iGUISelected = BOINC_ADVANCEDGUI;

405

}

406

407

// Screen reader in use?

408

if (IsAccessibilityEnabled()) {

409

m_iGUISelected = BOINC_ADVANCEDGUI;

410

}

411

}

412

413

414

// Initialize the task bar icon

415

m_pTaskBarIcon = new CTaskBarIcon(

416

m_pSkinManager->GetAdvanced()->GetApplicationName(),

417

m_pSkinManager->GetAdvanced()->GetApplicationIcon(),

418

m_pSkinManager->GetAdvanced()->GetApplicationDisconnectedIcon(),

419

m_pSkinManager->GetAdvanced()->GetApplicationSnoozeIcon()

420

);

421

wxASSERT(m_pTaskBarIcon);

422

#ifdef __WXMAC__

423

m_pMacSystemMenu = new CMacSystemMenu(

424

m_pSkinManager->GetAdvanced()->GetApplicationName(),

425

m_pSkinManager->GetAdvanced()->GetApplicationIcon(),

426

m_pSkinManager->GetAdvanced()->GetApplicationDisconnectedIcon(),

427

m_pSkinManager->GetAdvanced()->GetApplicationSnoozeIcon()

428

);

429

wxASSERT(m_pMacSystemMenu);

430

#endif

431

432

433

// Detect the display info and store for later use.

434

DetectDisplayInfo();

435

436

437

// Startup the System Idle Detection code

438

IdleTrackerAttach();

439

440

#ifdef __WXMAC__

441

ProcessSerialNumber psn;

442

ProcessInfoRec pInfo;

443

OSStatus err;

444

445

memset(&pInfo, 0, sizeof(pInfo));

446

pInfo.processInfoLength = sizeof( ProcessInfoRec );

447

err = GetProcessInformation(&m_psnCurrentProcess, &pInfo);

448

if (!err) {

449

psn = pInfo.processLauncher;

450

memset(&pInfo, 0, sizeof(pInfo));

451

pInfo.processInfoLength = sizeof( ProcessInfoRec );

452

err = GetProcessInformation(&psn, &pInfo);

453

}

454

// Don't open main window if we were started automatically at login

455

if (pInfo.processSignature == 'lgnw') { // Login Window app

456

m_bGUIVisible = false;

457

458

// If the system was just started, we usually get a "Connection

459

// failed" error if we try to connect too soon, so delay a bit.

460

sleep(10);

461

}

462

#endif

463

464

465

// Show the UI

466

SetActiveGUI(m_iGUISelected, false);

467

if (m_bGUIVisible) {

468

SetActiveGUI(m_iGUISelected);

469

} else {

470

ShowApplication(false);

471

}

472

473

if(bOpenEventLog) {

474

DisplayEventLog(m_bGUIVisible);

475

m_pFrame->Raise();

476

}

477

478

return true;

479

}

480

481

482

int CBOINCGUIApp::OnExit() {

483

// Shutdown the System Idle Detection code

484

IdleTrackerDetach();

485

486

if (m_pDocument) {

487

m_pDocument->OnExit();

488

delete m_pDocument;

489

m_pDocument = NULL;

490

}

491

492

m_pConfig->SetPath(wxT("/"));

493

if (m_pSkinManager) {

494

m_pConfig->Write(wxT("Skin"), m_pSkinManager->GetSelectedSkin());

495

delete m_pSkinManager;

496

}

497

498

if (m_pLocale) {

499

delete m_pLocale;

500

m_pLocale = NULL;

501

}

502

503

if (m_pEventLog) {

504

m_pEventLog->Destroy();

505

m_pEventLog = NULL;

506

}

507

508

509

// Save Application State

510

m_pConfig->Write(wxT("AutomaticallyShutdownClient"), m_iShutdownCoreClient);

511

m_pConfig->Write(wxT("DisplayShutdownClientDialog"), m_iDisplayExitDialog);

512

m_pConfig->Write(wxT("DisableAutoStart"), m_iBOINCMGRDisableAutoStart);

513

514

diagnostics_finish();

515

516

return wxApp::OnExit();

517

}

518

519

520

///

521

/// Pass the command line parameters and discriptions to wxWidgets for displaying.

522

///

523

void CBOINCGUIApp::OnInitCmdLine(wxCmdLineParser &parser) {

524

wxApp::OnInitCmdLine(parser);

525

static const wxCmdLineEntryDesc cmdLineDesc[] = {

526

{ wxCMD_LINE_SWITCH, wxT("a"), wxT("autostart"), _("BOINC Manager was started by the operating system automatically")},

527

#if defined(__WXMSW__) || defined(__WXMAC__)

528

{ wxCMD_LINE_SWITCH, wxT("s"), wxT("systray"), _("Startup BOINC so only the system tray icon is visible")},

529

#else

530

{ wxCMD_LINE_OPTION, wxT("e"), wxT("clientdir"), _("Directory containing the BOINC Client executable")},

531

{ wxCMD_LINE_OPTION, wxT("d"), wxT("datadir"), _("BOINC data directory")},

532

#endif

533

{ wxCMD_LINE_OPTION, wxT("n"), wxT("namehost"), _("Host name or IP address")},

534

{ wxCMD_LINE_OPTION, wxT("g"), wxT("gui_rpc_port"), _("GUI RPC port number")},

535

{ wxCMD_LINE_OPTION, wxT("p"), wxT("password"), _("Password")},

536

{ wxCMD_LINE_SWITCH, wxT("b"), wxT("boincargs"), _("Startup BOINC with these optional arguments")},

537

{ wxCMD_LINE_SWITCH, wxT("i"), wxT("insecure"), _("disable BOINC security users and permissions")},

538

{ wxCMD_LINE_SWITCH, wxT("c"), wxT("checkskins"), _("set skin debugging mode to enable skin manager error messages")},

539

{ wxCMD_LINE_SWITCH, wxT("m"), wxT("multiple"), _("multiple instances of BOINC Manager allowed")},

540

{ wxCMD_LINE_NONE} //DON'T forget this line!!

541

};

542

parser.SetDesc(cmdLineDesc);

543

}

544

545

546

///

547

/// Parse command line parameters.

548

///

549

bool CBOINCGUIApp::OnCmdLineParsed(wxCmdLineParser &parser) {

550

// Give default processing (-?, --help and --verbose) the chance to do something.

551

wxApp::OnCmdLineParsed(parser);

552

wxString portNum = wxEmptyString;

553

long longPort;

554

bool hostNameSpecified = false;

555

bool passwordSpecified = false;

556

557

parser.Found(wxT("boincargs"), &m_strBOINCArguments);

558

if (parser.Found(wxT("autostart"))) {

559

m_bBOINCMGRAutoStarted = true;

560

}

561

#if defined(__WXMSW__) || defined(__WXMAC__)

562

if (parser.Found(wxT("systray"))) {

563

m_bGUIVisible = false;

564

}

565

#endif

566

if (parser.Found(wxT("insecure"))) {

567

g_use_sandbox = false;

568

}

569

if (parser.Found(wxT("checkskins"))) {

570

m_bDebugSkins = true;

571

}

572

if (parser.Found(wxT("multiple"))) {

573

m_bMultipleInstancesOK = true;

574

}

575

576

#if !(defined(__WXMSW__) || defined(__WXMAC__))

577

if (!parser.Found(wxT("clientdir"), &m_strBOINCMGRRootDirectory)) {

578

m_strBOINCMGRRootDirectory = ::wxGetCwd();

579

}

580

if (m_strBOINCMGRRootDirectory.Last() != '/') {

581

m_strBOINCMGRRootDirectory.Append('/');

582

}

583

584

if (!parser.Found(wxT("datadir"), &m_strBOINCMGRDataDirectory)) {

585

m_strBOINCMGRDataDirectory = m_strBOINCMGRRootDirectory;

586

}

587

if (m_strBOINCMGRDataDirectory.Last() != '/') {

588

m_strBOINCMGRDataDirectory.Append('/');

589

}

590

#endif

591

592

if (parser.Found(wxT("namehost"), &m_strHostNameArg)) {

593

hostNameSpecified = true;

594

} else {

595

m_strHostNameArg = wxT("localhost");

596

}

597

598

if (parser.Found(wxT("gui_rpc_port"), &portNum)) {

599

if (portNum.ToLong(&longPort)) {

600

m_iRPCPortArg = longPort;

601

} else {

602

m_iRPCPortArg = GUI_RPC_PORT; // conversion failed

603

}

604

} else {

605

m_iRPCPortArg = GUI_RPC_PORT;

606

}

607

608

if (parser.Found(wxT("password"), &m_strPasswordArg)) {

609

passwordSpecified = true;

610

} else {

611

m_strPasswordArg = wxEmptyString;

612

}

613

614

if (hostNameSpecified && passwordSpecified) {

615

m_bMultipleInstancesOK = true;

616

}

617

return true;

618

}

619

620

621

///

622

/// Detect the desktop that BOINC Manager is running in.

623

///

624

void CBOINCGUIApp::DetectDisplayInfo() {

625

#ifdef __WXMSW__

626

wxChar szWindowStation[256];

627

memset(szWindowStation, 0, sizeof(szWindowStation)/sizeof(wxChar));

628

wxChar szDesktop[256];

629

memset(szDesktop, 0, sizeof(szDesktop)/sizeof(wxChar));

630

631

if (wxWIN95 != wxGetOsVersion(NULL, NULL)) {

632

// Retrieve the current window station and desktop names

633

GetUserObjectInformation(

634

GetProcessWindowStation(),

635

UOI_NAME,

636

szWindowStation,

637

(sizeof(szWindowStation) / sizeof(wxChar)),

638

NULL

639

);

640

GetUserObjectInformation(

641

GetThreadDesktop(GetCurrentThreadId()),

642

UOI_NAME,

643

szDesktop,

644

(sizeof(szDesktop) / sizeof(wxChar)),

645

NULL

646

);

647

m_strDefaultWindowStation = szWindowStation;

648

m_strDefaultDesktop = szDesktop;

649

}

650

651

#else

652

wxString p = wxString(getenv("DISPLAY"), wxConvUTF8);

653

if (p) m_strDefaultDisplay = p;

654

#endif

655

656

}

657

658

659

///

660

/// Detect if an acessibility aid is running on the system.

661

///

662

void CBOINCGUIApp::DetectAccessibilityEnabled() {

663

#ifdef __WXMSW__

664

BOOL bScreenReaderEnabled = false;

665

SystemParametersInfo(SPI_GETSCREENREADER, NULL, &bScreenReaderEnabled, NULL);

666

m_bAccessibilityEnabled = (bScreenReaderEnabled == TRUE);

667

#endif

668

}

669

670

671

///

672

/// Detect if another instance of this application is running.

673

// Returns true if there is, otherwise false

674

///

675

bool CBOINCGUIApp::DetectDuplicateInstance() {

676

#ifdef __WXMSW__

677

if (CTaskBarIcon::FireAppRestore()) {

678

return true;

679

}

680

#endif

681

#ifdef __WXMAC__

682

ProcessSerialNumber PSN;

683

int iInstanceID = wxGetApp().IsAnotherInstanceRunning();

684

if (iInstanceID) {

685

// Bring other instance to the front and exit this instance

686

OSStatus err = GetProcessForPID(iInstanceID, &PSN);

687

if (!err) SetFrontProcess(&PSN);

688

return true;

689

}

690

#endif

691

return false;

692

}

693

694

695

///

696

/// Determines what name BOINC Manager is called.

697

///

698

void CBOINCGUIApp::DetectExecutableName() {

699

#ifdef __WXMSW__

700

TCHAR szPath[MAX_PATH-1];

701

702

// change the current directory to the boinc install directory

703

GetModuleFileName(NULL, szPath, (sizeof(szPath)/sizeof(TCHAR)));

704

705

TCHAR *pszProg = _tcsrchr(szPath, '\\');

706

if (pszProg) {

707

pszProg++;

708

}

709

710

// Store the root directory for later use.

711

m_strBOINCMGRExecutableName = pszProg;

712

#endif

713

}

714

715

716

///

717

/// Determines where the BOINC Manager is executing from.

718

///

719

void CBOINCGUIApp::DetectRootDirectory() {

720

#ifdef __WXMSW__

721

TCHAR szPath[MAX_PATH-1];

722

723

// change the current directory to the boinc install directory

724

GetModuleFileName(NULL, szPath, (sizeof(szPath)/sizeof(TCHAR)));

725

726

TCHAR *pszProg = _tcsrchr(szPath, '\\');

727

if (pszProg) {

728

szPath[pszProg - szPath + 1] = 0;

729

}

730

731

// Store the root directory for later use.

732

m_strBOINCMGRRootDirectory = szPath;

733

#endif

734

}

735

736

737

///

738

/// Determines where the BOINC data directory is.

739

///

740

void CBOINCGUIApp::DetectDataDirectory() {

741

#ifdef __WXMSW__

742

743

// Determine BOINCMgr Data Directory

744

745

LONG lReturnValue;

746

HKEY hkSetupHive;

747

LPTSTR lpszRegistryValue = NULL;

748

DWORD dwSize = 0;

749

750

// change the current directory to the boinc data directory if it exists

751

lReturnValue = RegOpenKeyEx(

752

HKEY_LOCAL_MACHINE,

753

_T("SOFTWARE\\Space Sciences Laboratory, U.C. Berkeley\\BOINC Setup"),

754

755

KEY_READ,

756

&hkSetupHive

757

);

758

if (lReturnValue == ERROR_SUCCESS) {

759

// How large does our buffer need to be?

760

lReturnValue = RegQueryValueEx(

761

hkSetupHive,

762

_T("DATADIR"),

763

NULL,

764

NULL,

765

NULL,

766

&dwSize

767

);

768

if (lReturnValue != ERROR_FILE_NOT_FOUND) {

769

// Allocate the buffer space.

770

lpszRegistryValue = (LPTSTR) malloc(dwSize);

771

(*lpszRegistryValue) = NULL;

772

773

// Now get the data

774

lReturnValue = RegQueryValueEx(

775

hkSetupHive,

776

_T("DATADIR"),

777

NULL,

778

NULL,

779

(LPBYTE)lpszRegistryValue,

780

&dwSize

781

);

782

783

// Store the root directory for later use.

784

m_strBOINCMGRDataDirectory = lpszRegistryValue;

785

}

786

}

787

788

// Cleanup

789

if (hkSetupHive) RegCloseKey(hkSetupHive);

790

if (lpszRegistryValue) free(lpszRegistryValue);

791

#endif

792

#ifdef __WXMAC__

793

m_strBOINCMGRDataDirectory = wxT("/Library/Application Support/BOINC Data");

794

#endif

795

}

796

797

798

void CBOINCGUIApp::InitSupportedLanguages() {

799

wxInt32 iIndex = 0;

800

const wxLanguageInfo* liLanguage = NULL;

801

802

// Prepare the array

803

m_astrLanguages.Insert(wxEmptyString, 0, wxLANGUAGE_USER_DEFINED+1);

804

805

// These are just special tags so deal with them in a special way

806

m_astrLanguages[wxLANGUAGE_DEFAULT] = _("(Automatic Detection)");

807

m_astrLanguages[wxLANGUAGE_UNKNOWN] = _("(Unknown)");

808

m_astrLanguages[wxLANGUAGE_USER_DEFINED] = _("(User Defined)");

809

810

for (iIndex = 0; iIndex <= wxLANGUAGE_USER_DEFINED; iIndex++) {

811

liLanguage = wxLocale::GetLanguageInfo(iIndex);

812

if (liLanguage) {

813

m_astrLanguages[iIndex] = liLanguage->Description;

814

}

815

}

816

}

817

818

819

int CBOINCGUIApp::IdleTrackerAttach() {

820

#ifdef __WXMSW__

821

::attach_idle_monitor();

822

#endif

823

return 0;

824

}

825

826

827

int CBOINCGUIApp::IdleTrackerDetach() {

828

#ifdef __WXMSW__

829

::detach_idle_monitor();

830

#endif

831

return 0;

832

}

833

834

835

void CBOINCGUIApp::OnRPCFinished( CRPCFinishedEvent& event ) {

836

CMainDocument* pDoc = wxGetApp().GetDocument();

837

838

wxASSERT(pDoc);

839

wxASSERT(wxDynamicCast(pDoc, CMainDocument));

840

841

pDoc->OnRPCComplete(event);

842

}

843

844

845

int CBOINCGUIApp::UpdateSystemIdleDetection() {

846

#ifdef __WXMSW__

847

return get_idle_tick_count();

848

#else

849

return TRUE;

850

#endif

851

}

852

853

854

int CBOINCGUIApp::StartBOINCScreensaverTest() {

855

#ifdef __WXMSW__

856

wxString strExecute = wxEmptyString;

857

wxChar szExecutableDirectory[4096];

858

memset(szExecutableDirectory, 0, sizeof(szExecutableDirectory));

859

860

// On Windows the screensaver is located in the Windows directory.

861

GetWindowsDirectory(

862

szExecutableDirectory,

863

(sizeof(szExecutableDirectory) / sizeof(wxChar))

864

);

865

866

// Append boinc.scr to the end of the strExecute string and get ready to rock

867

strExecute = wxT("\"") + wxString(szExecutableDirectory) + wxT("\\boinc.scr\" /t");

868

::wxExecute(strExecute);

869

#endif

870

return 0;

871

}

872

873

874

int CBOINCGUIApp::StartBOINCDefaultScreensaverTest() {

875

#ifdef __WXMSW__

876

wxString strExecute = wxEmptyString;

877

strExecute = wxT("\"") + m_strBOINCMGRRootDirectory + wxT("\\boincscr.exe\" --test");

878

::wxExecute(strExecute);

879

#endif

880

return 0;

881

}

882

883

884

// Display the Event Log, it is a modeless dialog not owned by any

885

// other UI element.

886

void CBOINCGUIApp::DisplayEventLog(bool bShowWindow) {

887

if (m_pEventLog ) {

888

if (bShowWindow) {

889

m_pEventLog->Raise();

890

}

891

} else {

892

m_pEventLog = new CDlgEventLog();

893

if (m_pEventLog) {

894

m_pEventLog->Show(bShowWindow);

895

if (bShowWindow) {

896

m_pEventLog->Raise();

897

}

898

if (m_pFrame) {

899

m_pFrame->UpdateRefreshTimerInterval();

900

}

901

}

902

}

903

}

904

905

906

void CBOINCGUIApp::OnEventLogClose() {

907

m_pEventLog = NULL;

908

if (m_pFrame) {

909

m_pFrame->UpdateRefreshTimerInterval();

910

}

911

}

912

913

914

// The skin has changed and all UI elements need to reload their bitmaps.

915

916

void CBOINCGUIApp::FireReloadSkin() {

917

if (m_pFrame) {

918

m_pFrame->FireReloadSkin();

919

}

920

if (m_pTaskBarIcon) {

921

m_pTaskBarIcon->FireReloadSkin();

922

}

923

}

924

925

926

bool CBOINCGUIApp::SetActiveGUI(int iGUISelection, bool bShowWindow) {

927

CBOINCBaseFrame* pNewFrame = NULL;

928

CBOINCBaseFrame* pOldFrame = m_pFrame;

929

wxInt32 iTop = 0;

930

wxInt32 iLeft = 0;

931

wxInt32 iHeight = 0;

932

wxInt32 iWidth = 0;

933

934

935

// Create the new window

936

if ((iGUISelection != m_iGUISelected) || !m_pFrame) {

937

938

// Reterieve the desired window state before creating the

939

// desired frames

940

if (BOINC_ADVANCEDGUI == iGUISelection) {

941

m_pConfig->SetPath(wxT("/"));

942

m_pConfig->Read(wxT("YPos"), &iTop, 30);

943

m_pConfig->Read(wxT("XPos"), &iLeft, 30);

944

m_pConfig->Read(wxT("Width"), &iWidth, 800);

945

m_pConfig->Read(wxT("Height"), &iHeight, 600);

946

} else {

947

m_pConfig->SetPath(wxT("/Simple"));

948

m_pConfig->Read(wxT("YPos"), &iTop, 30);

949

m_pConfig->Read(wxT("XPos"), &iLeft, 30);

950

#ifdef __WXMAC__

951

m_pConfig->Read(wxT("Width"), &iWidth, 409);

952

m_pConfig->Read(wxT("Height"), &iHeight, 561);

953

#else

954

m_pConfig->Read(wxT("Width"), &iWidth, 416);

955

m_pConfig->Read(wxT("Height"), &iHeight, 570);

956

#endif

957

}

958

959

960

// Make sure that the new window is going to be visible

961

// on a screen

962

#ifdef __WXMAC__

963

Rect titleRect = {iTop, iLeft, iTop+22, iLeft+iWidth };

964

InsetRect(&titleRect, 5, 5); // Make sure at least a 5X5 piece visible

965

RgnHandle displayRgn = NewRgn();

966

CopyRgn(GetGrayRgn(), displayRgn); // Region encompassing all displays

967

Rect menuRect = ((**GetMainDevice())).gdRect;

968

menuRect.bottom = GetMBarHeight() + menuRect.top;

969

RgnHandle menuRgn = NewRgn();

970

RectRgn(menuRgn, &menuRect); // Region hidden by menu bar

971

DiffRgn(displayRgn, menuRgn, displayRgn); // Subtract menu bar retion

972

if (!RectInRgn(&titleRect, displayRgn))

973

iTop = iLeft = 30;

974

DisposeRgn(menuRgn);

975

DisposeRgn(displayRgn);

976

#else

977

// If either co-ordinate is less then 0 then set it equal to 0 to ensure

978

// it displays on the screen.

979

if ( iLeft < 0 ) iLeft = 30;

980

if ( iTop < 0 ) iTop = 30;

981

982

// Read the size of the screen

983

wxInt32 iMaxWidth = wxSystemSettings::GetMetric( wxSYS_SCREEN_X );

984

wxInt32 iMaxHeight = wxSystemSettings::GetMetric( wxSYS_SCREEN_Y );

985

986

// Max sure that it doesn't go off to the right or bottom

987

if ( iLeft + iWidth > iMaxWidth ) iLeft = iMaxWidth - iWidth;

988

if ( iTop + iHeight > iMaxHeight ) iTop = iMaxHeight - iHeight;

989

#endif

990

991

// Create the main window

992

993

if (BOINC_ADVANCEDGUI == iGUISelection) {

994

// Initialize the advanced gui window

995

pNewFrame = new CAdvancedFrame(

996

m_pSkinManager->GetAdvanced()->GetApplicationName(),

997

m_pSkinManager->GetAdvanced()->GetApplicationIcon(),

998

m_pSkinManager->GetAdvanced()->GetApplicationIcon32(),

999

wxPoint(iLeft, iTop),

1000

wxSize(iWidth, iHeight)

1001

);

1002

} else {

1003

// Initialize the simple gui window

1004

pNewFrame = new CSimpleFrame(

1005

m_pSkinManager->GetAdvanced()->GetApplicationName(),

1006

m_pSkinManager->GetAdvanced()->GetApplicationIcon(),

1007

m_pSkinManager->GetAdvanced()->GetApplicationIcon32(),

1008

wxPoint(iLeft, iTop),

1009

wxSize(iWidth, iHeight)

1010

);

1011

}

1012

1013

wxASSERT(pNewFrame);

1014

1015

if (pNewFrame) {

1016

SetTopWindow(pNewFrame);

1017

1018

// Store the new frame for future use

1019

m_pFrame = pNewFrame;

1020

1021

// Hide the old one if it exists. We must do this

1022

// after updating m_pFrame to prevent Mac OSX from

1023

// hiding the application

1024

if (pOldFrame) pOldFrame->Hide();

1025

1026

// Delete the old one if it exists

1027

// Note: this has the side effect of hiding the Event Log

1028

if (pOldFrame) pOldFrame->Destroy();

1029

1030

// Show the new frame if needed (and show the Event Log if open)

1031

if (pNewFrame && bShowWindow) pNewFrame->Show();

1032

}

1033

}

1034

1035

// Show the new frame if needed

1036

if (m_pFrame && !m_pFrame->IsShown() && bShowWindow) {

1037

m_pFrame->Show();

1038

m_pFrame->Raise();

1039

#ifdef __WXMSW__

1040

::SetForegroundWindow((HWND)m_pFrame->GetHWND());

1041

#endif

1042

}

1043

1044

// Raise the frame to the top of the Z order if needed

1045

if (m_pFrame && m_pFrame->IsShown() && bShowWindow) {

1046

m_pFrame->Raise();

1047

#ifdef __WXMSW__

1048

::SetForegroundWindow((HWND)m_pFrame->GetHWND());

1049

#endif

1050

}

1051

1052

m_iGUISelected = iGUISelection;

1053

m_pConfig->SetPath(wxT("/"));

1054

m_pConfig->Write(wxT("GUISelection"), iGUISelection);

1055

1056

return true;

1057

}

1058

1059

1060

int CBOINCGUIApp::ConfirmExit() {

1061

CSkinAdvanced* pSkinAdvanced = wxGetApp().GetSkinManager()->GetAdvanced();

1062

CMainDocument* pDoc = wxGetApp().GetDocument();

1063

wxString strConnectedCompter = wxEmptyString;

1064

bool bWasVisible;

1065

int retval = 0;

1066

1067

wxASSERT(pDoc);

1068

wxASSERT(pSkinAdvanced);

1069

wxASSERT(wxDynamicCast(pDoc, CMainDocument));

1070

wxASSERT(wxDynamicCast(pSkinAdvanced, CSkinAdvanced));

1071

1072

pDoc->GetConnectedComputerName(strConnectedCompter);

1073

if (!pDoc->IsComputerNameLocal(strConnectedCompter)) {

1074

// Don't shut down remote clients on Manager exit

1075

return 1;

1076

}

1077

1078

// Don't run confirmation dialog if logging out or shutting down Mac,

1079

// or if emergency exit from AsyncRPCDlg

1080

if (s_bSkipExitConfirmation)

1081

return 1;

1082

1083

#ifndef __WXMSW__

1084

if (!m_iDisplayExitDialog) {

1085

return 1; // User doesn't want to display the dialog and wants to shutdown the client.

1086

}

1087

#else

1088

if (!m_iDisplayExitDialog) {

1089

return 1; // User doesn't want to display the dialog and just wants to use their previous value

1090

}

1091

#endif

1092

1093

bWasVisible = IsApplicationVisible();

1094

ShowApplication(true);

1095

1096

CDlgExitMessage dlg(NULL);

1097

1098

if (!pSkinAdvanced->GetExitMessage().IsEmpty()) {

1099

dlg.m_DialogExitMessage->SetLabel(pSkinAdvanced->GetExitMessage());

1100

}

1101

1102

#ifdef __WXMSW__

1103

if (m_iShutdownCoreClient) {

1104

dlg.m_DialogShutdownCoreClient->SetValue(TRUE);

1105

}

1106

#endif

1107

1108

if (m_iDisplayExitDialog) {

1109

dlg.m_DialogDisplay->SetValue(FALSE);

1110

}

1111

1112

dlg.Fit();

1113

dlg.Centre();

1114

1115

if (wxID_OK == dlg.ShowModal()) {

1116

#ifndef __WXMSW__

1117

s_bSkipExitConfirmation = true; // Don't ask twice (only affects Mac)

1118

#else

1119

m_iShutdownCoreClient = dlg.m_DialogShutdownCoreClient->GetValue();

1120

#endif

1121

m_iDisplayExitDialog = !dlg.m_DialogDisplay->GetValue();

1122

retval = true;

1123

1124

}

1125

1126

if (!bWasVisible) {

1127

ShowApplication(false);

1128

}

1129

1130

return retval; // User cancelled exit

1131

}

1132

1133

1134

// Use this instead of wxMessageBox from all tab Views to suppress

1135

// Periodic RPCs. See comment in CMainDocument::RunPeriodicRPCs()

1136

// for a fuller explanation.

1137

int CBOINCGUIApp::SafeMessageBox(const wxString& message, const wxString& caption, long style,

1138

wxWindow *parent, int x, int y )

1139

{

1140

int retval;

1141

1142

m_bSafeMessageBoxDisplayed++;

1143

1144

retval = wxMessageBox(message, caption, style, parent, x, y);

1145

1146

m_bSafeMessageBoxDisplayed--;

1147

1148

return retval;

1149

}

1150

1151

1152

///

1153

/// Determines if another instance of BOINC Manager is running.

1154

///

1155

/// @return

1156

/// true if another instance of BOINC Manager is running, otherwise false.

1157

///

1158

/// Note: will always return false on Win95, Win98, WinME

1159

///

1160

int CBOINCGUIApp::IsAnotherInstanceRunning() {

1161

std::vector<PROCINFO> piv;

1162

PROCINFO* pi;

1163

int retval;

1164

char myName[256];

1165

int otherInstanceID = 0;

1166

int myPid;

1167

1168

// Look for BOINC Manager in list of all running processes

1169

retval = procinfo_setup(piv);

1170

if (retval) return false; // Should never happen

1171

1172

#ifdef _WIN32

1173

myPid = (int)GetCurrentProcessId();

1174

#else

1175

myPid = getpid();

1176

#endif

1177

1178

// Get the name of this Application

1179

myName[0] = 0;

1180

for (unsigned int i=0; i<piv.size(); i++) {

1181

pi = &(piv[i]);

1182

if (pi->id == myPid) {

1183

strncpy(myName, pi->command, sizeof(myName));

1184

break;

1185

}

1186

}

1187

1188

if (myName[0] == 0) {

1189

return false; // Should never happen

1190

}

1191

1192

// Search process list for other applications with same name

1193

for (unsigned int i=0; i<piv.size(); i++) {

1194

pi = &(piv[i]);

1195

if (pi->id == myPid) continue;

1196

if (!strcmp(pi->command, myName)) {

1197

otherInstanceID = pi->id;

1198

break;

1199

}

1200

}

1201

1202

return otherInstanceID;

1203

}

1204

1205

1206

///

1207

/// Determines if the current process is visible.

1208

///

1209

/// @return

1210

/// true if the current process is visible, otherwise false.

1211

///

1212

bool CBOINCGUIApp::IsApplicationVisible() {

1213

#ifdef __WXMAC__

1214

if (IsProcessVisible(&m_psnCurrentProcess)) {

1215

return true;

1216

}

1217

#endif

1218

return false;

1219

}

1220

1221

///

1222

/// Shows or hides the current process.

1223

///

1224

/// @param bShow

1225

/// true will show the process, false will hide the process.

1226

///

1227

#ifdef __WXMAC__

1228

void CBOINCGUIApp::ShowApplication(bool bShow) {

1229

if (bShow) {

1230

SetFrontProcess(&m_psnCurrentProcess);

1231

} else {

1232

ShowHideProcess(&m_psnCurrentProcess, false);

1233

}

1234

}

1235

#else

1236

void CBOINCGUIApp::ShowApplication(bool) {

1237

}

1238

#endif

1239

1240

1241

bool CBOINCGUIApp::ShowInterface() {

1242

return SetActiveGUI(m_iGUISelected, true);

1243

}

1244

1245

1246

bool CBOINCGUIApp::ShowNotifications() {

1247

bool retval = false;

1248

1249

retval = SetActiveGUI(m_iGUISelected, true);

1250

if (retval) {

1251

GetFrame()->FireNotification();

1252

GetDocument()->UpdateUnreadNoticeState();

1253

}

1254

1255

return retval;

1256

}

1257

1258

1259

bool CBOINCGUIApp::IsModalDialogDisplayed() {

1260

if (m_bSafeMessageBoxDisplayed) return true;

1261

1262

// Search for the dialog by ID since all of BOINC Manager's

1263

// dialog IDs are 10000.

1264

if (wxDynamicCast(wxWindow::FindWindowById(ID_ANYDIALOG), wxDialog)) {

1265

return true;

1266

}

1267

1268

if (m_pDocument) {

1269

if (m_pDocument->WaitingForRPC()) {

1270

return true;

1271

}

1272

}

1273

return false;

1274

}

1275

1276

void CBOINCGUIApp::DeleteTaskBarIcon() {

1277

if (m_pTaskBarIcon) {

1278

delete m_pTaskBarIcon;

1279

}

1280

m_pTaskBarIcon = NULL;

1281

}

1282

1283

#ifdef __WXMAC__

1284

void CBOINCGUIApp::DeleteMacSystemMenu() {

1285

if (m_pMacSystemMenu) {

1286

delete m_pMacSystemMenu;

1287

}

1288

m_pMacSystemMenu = NULL;

1289

}

1290

#endif

1291

1292

1293

// Prevent recursive entry of CMainDocument::RequestRPC()

1294

int CBOINCGUIApp::FilterEvent(wxEvent &event) {

1295

if (!m_pDocument) return -1;

1296

if (!m_pDocument->WaitingForRPC()) return -1;

1297

1298

// If in RPC Please Wait dialog, reject all command

1299

// and timer events except:

1300

// - RPC Finished

1301

// - those for that dialog or its children

1302

// - Open Manager menu item from system tray icon

1303

int theEventType = event.GetEventType();

1304

1305

if ((theEventType == wxEVT_COMMAND_MENU_SELECTED) && (event.GetId() == wxID_OPEN)) {

1306

return -1;

1307

}

1308

1309

wxDialog* theRPCWaitDialog = m_pDocument->GetRPCWaitDialog();

1310

wxObject* theObject = event.GetEventObject();

1311

while (theObject) {

1312

if (!theObject->IsKindOf(CLASSINFO(wxWindow))) break;

1313

if (theObject == theRPCWaitDialog) return -1;

1314

theObject = ((wxWindow*)theObject)->GetParent();

1315

}

1316

1317

// Allow all except Command, Timer and Mouse Moved events

1318

if (event.IsCommandEvent()) {

1319

return false;

1320

}

1321

1322

if (theEventType == wxEVT_TIMER) {

1323

return false;

1324

}

1325

1326

#ifdef __WXMSW__

1327

if (theEventType == wxEVT_TASKBAR_MOVE) {

1328

return false;

1329

}

1330

#endif

1331

1332

return -1;

1333

}

1334

Older »