haiku.git

/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2011-2016, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */


#include "GraphicalUserInterface.h"

#include <Alert.h>
#include <AutoDeleter.h>
#include <Autolock.h>
#include <FilePanel.h>
#include <Locker.h>

#include "AlertWithCheckbox.h"
#include "GuiTeamUiSettings.h"
#include "MessageCodes.h"
#include "TeamWindow.h"
#include "Tracing.h"


// #pragma mark - GraphicalUserInterface::FilePanelHandler


class GraphicalUserInterface::FilePanelHandler : public BHandler {
public:
								FilePanelHandler();
	virtual						~FilePanelHandler();

			status_t			Init();

	virtual	void				MessageReceived(BMessage* message);

			status_t			WaitForPanel();

			void				SetCurrentRef(entry_ref* ref);

			BLocker&			Locker()
									{ return fPanelLock; }

private:
			entry_ref*			fCurrentRef;
			BLocker				fPanelLock;
			sem_id				fPanelWaitSem;
};


GraphicalUserInterface::FilePanelHandler::FilePanelHandler()
	:
	BHandler("GuiPanelHandler"),
	fCurrentRef(NULL),
	fPanelLock(),
	fPanelWaitSem(-1)
{
}


GraphicalUserInterface::FilePanelHandler::~FilePanelHandler()
{
	if (fPanelWaitSem >= 0)
		delete_sem(fPanelWaitSem);
}


status_t
GraphicalUserInterface::FilePanelHandler::Init()
{
	fPanelWaitSem = create_sem(0, "FilePanelWaitSem");

	if (fPanelWaitSem < 0)
		return fPanelWaitSem;

	return B_OK;
}


void
GraphicalUserInterface::FilePanelHandler::MessageReceived(BMessage* message)
{
	switch (message->what) {
		case MSG_USER_INTERFACE_FILE_CHOSEN:
		{
			entry_ref ref;
			if (message->FindRef("refs", &ref) == B_OK
				&& fCurrentRef != NULL) {
				*fCurrentRef = ref;
				fCurrentRef = NULL;
			}
			// fall through
		}

		case B_CANCEL:
		{
			release_sem(fPanelWaitSem);
			break;
		}

		default:
			BHandler::MessageReceived(message);
			break;
	}
}


status_t
GraphicalUserInterface::FilePanelHandler::WaitForPanel()
{
	status_t result = B_OK;
	do {
		result = acquire_sem(fPanelWaitSem);
	} while (result == B_INTERRUPTED);

	return result;
}


void
GraphicalUserInterface::FilePanelHandler::SetCurrentRef(entry_ref* ref)
{
	fCurrentRef = ref;
}


// #pragma mark - GraphicalUserInterface


GraphicalUserInterface::GraphicalUserInterface()
	:
	fTeamWindow(NULL),
	fTeamWindowMessenger(NULL),
	fFilePanelHandler(NULL),
	fFilePanel(NULL),
	fDefaultActions(10)
{
}


GraphicalUserInterface::~GraphicalUserInterface()
{
	delete fTeamWindowMessenger;
	delete fFilePanel;
	delete fFilePanelHandler;
}


const char*
GraphicalUserInterface::ID() const
{
	return "GraphicalUserInterface";
}


status_t
GraphicalUserInterface::Init(Team* team, UserInterfaceListener* listener)
{
	try {
		fTeamWindow = TeamWindow::Create(team, listener);
		fTeamWindowMessenger = new BMessenger(fTeamWindow);
		fFilePanelHandler = new FilePanelHandler();
		status_t error = fFilePanelHandler->Init();
		if (error != B_OK) {
			ERROR("Error: Failed to create file panel semaphore!\n");
			return error;
		}
		fTeamWindow->AddHandler(fFilePanelHandler);

		// start the message loop
		fTeamWindow->Hide();
		fTeamWindow->Show();
	} catch (...) {
		// TODO: Notify the user!
		ERROR("Error: Failed to create team window!\n");
		return B_NO_MEMORY;
	}

	return B_OK;
}


void
GraphicalUserInterface::Show()
{
	if (fTeamWindow->IsHidden())
		fTeamWindow->Show();
	else
		fTeamWindow->Activate();
}


void
GraphicalUserInterface::Terminate()
{
	// quit window
	if (fTeamWindowMessenger && fTeamWindowMessenger->LockTarget())
		fTeamWindow->Quit();
}


UserInterface*
GraphicalUserInterface::Clone() const
{
	return new(std::nothrow) GraphicalUserInterface;
}


bool
GraphicalUserInterface::IsInteractive() const
{
	return true;
}


status_t
GraphicalUserInterface::LoadSettings(const TeamUiSettings* settings)
{
	status_t result = fTeamWindow->LoadSettings((GuiTeamUiSettings*)settings);

	return result;
}


status_t
GraphicalUserInterface::SaveSettings(TeamUiSettings*& settings) const
{
	settings = new(std::nothrow) GuiTeamUiSettings(ID());
	if (settings == NULL)
		return B_NO_MEMORY;

	fTeamWindow->SaveSettings((GuiTeamUiSettings*)settings);

	return B_OK;
}


void
GraphicalUserInterface::NotifyUser(const char* title, const char* message,
	user_notification_type type)
{
	// convert notification type to alert type
	alert_type alertType;
	switch (type) {
		case USER_NOTIFICATION_INFO:
			alertType = B_INFO_ALERT;
			break;
		case USER_NOTIFICATION_WARNING:
		case USER_NOTIFICATION_ERROR:
		default:
			alertType = B_WARNING_ALERT;
			break;
	}

	BAlert* alert = new(std::nothrow) BAlert(title, message, "OK",
		NULL, NULL, B_WIDTH_AS_USUAL, alertType);
	if (alert != NULL)
		alert->Go(NULL);

	// TODO: We need to let the alert run asynchronously, but we shouldn't just
	// create it and don't care anymore. Maybe an error window, which can
	// display a list of errors would be the better choice.
}


void
GraphicalUserInterface::NotifyBackgroundWorkStatus(const char* message)
{
	fTeamWindow->DisplayBackgroundStatus(message);
}


int32
GraphicalUserInterface::SynchronouslyAskUser(const char* title,
	const char* message, const char* choice1, const char* choice2,
	const char* choice3)
{
	// If the user already answered the question and asked for their choice to be remembered,
	// return the previously made choice again
	BString key(title);
	key += choice1;
	key += choice2;
	key += choice3;

	for (int i = 0; i < fDefaultActions.CountItems(); i++) {
		if (fDefaultActions.ItemAt(i)->fKey == key)
			return fDefaultActions.ItemAt(i)->fDecision;
	}

	AlertWithCheckbox* alert = new(std::nothrow) AlertWithCheckbox(title, message,
		"Don't ask again", choice1, choice2, choice3);

	if (alert == NULL)
		return 0;

	bool dontAskAgain = false;
	int result = alert->Go(dontAskAgain);

	if (dontAskAgain) {
		DefaultAction* defaultAction = new DefaultAction;
		defaultAction->fKey = key;
		defaultAction->fDecision = result;
		fDefaultActions.AddItem(defaultAction);
	}

	return result;
}


status_t
GraphicalUserInterface::SynchronouslyAskUserForFile(entry_ref* _ref)
{
	BAutolock lock(&fFilePanelHandler->Locker());

	if (fFilePanel == NULL) {
		BMessenger messenger(fFilePanelHandler);
		BMessage* message = new(std::nothrow) BMessage(
			MSG_USER_INTERFACE_FILE_CHOSEN);
		if (message == NULL)
			return B_NO_MEMORY;
		ObjectDeleter<BMessage> messageDeleter(message);
		fFilePanel = new(std::nothrow) BFilePanel(B_OPEN_PANEL,
			&messenger, NULL, B_FILE_NODE, false, message);
		if (fFilePanel == NULL)
			return B_NO_MEMORY;
		messageDeleter.Detach();
	}

	fFilePanelHandler->SetCurrentRef(_ref);
	fFilePanel->Show();
	return fFilePanelHandler->WaitForPanel();
}