StateLayer::StateLayer(ViewLayer& view)
{
mappings[&view] = this;
_view = &view;
_project = new Project();
assembly::Assembly& assembly = _project->getAssembly();
_selectionModel = new SelectionModel();
_view->constructShots(assembly);
_view->populateConceptSelectCombo(assembly.getOntology());
_view->rendererBoundsChanged();
scenegraph::Shot& shot = view.getRootShot();
_renderingState = new RenderingState(shot);
_defaultPerspective = new SearchPerspective();
_currentPerspective = _defaultPerspective;
_currentInteractionState = new SelectState(*_renderingState);
_currentPerspective->activate(*_view);
WindowRef window = _view->getWindow();
ActivateWindow(window, true);
SetPortWindowPort(window);
ShowWindow(window);
SelectWindow(window);
ActivateWindow(window, true);
_selectedLayer = 0;
_creationType = 0;
}
void _glfwPlatformRestoreWindow( void )
{
if( _glfwWin.Fullscreen )
{
ScreenToFront( _glfwWin.Screen );
}
WindowToFront( _glfwWin.Window );
ActivateWindow( _glfwWin.Window );
_glfwWin.Iconified = GL_FALSE;
}
void DatabaseConnectionWindow::Show()
{
if(IsSilent)
{
QTimer::singleShot(20000,this,SLOT(Timeout()));
}else
{
QTimer::singleShot(3000,this,SLOT(ActivateWindow()));
}
}
void QuartzWindow::activate() {
WindowPtr wp = my_window();
if (!IsWindowVisible(wp))
ShowWindow(wp);
SelectWindow(wp);
OSStatus e = SetUserFocusWindow(wp);
if (e) lprintf("SetUserFocus %d\n", e);
e = ActivateWindow(wp, true);
if (e) lprintf("ActivateWindow %d\n", e);
}
bool nuiWindowManager::KeyDown(const nglKeyEvent& rEvent)
{
if (rEvent.mKey == NK_TAB)
{
if (IsKeyDown(NK_LCTRL) || IsKeyDown(NK_LCTRL))
{
if (mpChildren.front() && mpChildren.size())
{
// if (!(((nuiWindow*)mpChildren.front())->IsModal()))
{
nuiWidgetList::iterator it;
nuiWidgetList::iterator end = mpChildren.begin();
it = mpChildren.end();
it--;
for (; it!=end; it--)
{
if (*it)
{
if ((*it)->IsVisible())
{
ActivateWindow((nuiWindow*)*it);
return true;
}
}
}
if (*it)
{
if ((*it)->IsVisible())
{
ActivateWindow((nuiWindow*)*it);
return true;
}
}
}
}
}
}
return false;
}
void WindowManager::RegisterWindow(RenderWindow* winPtr) {
#if defined( NEX_WINDOWS )
Win32Window* window = static_cast<Win32Window*>(winPtr);
HWND wndH = window->GetWindowHandle();
SetWindowLongPtr(wndH, GWLP_USERDATA,
reinterpret_cast<LONG_PTR>(window));
WNDPROC proc = reinterpret_cast<WNDPROC>(SetWindowLongPtr(wndH,
GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(&Win32Window::WndProc)));
window->SetWindowProc(proc);
#endif
registeredWindows.push_back(winPtr);
ActivateWindow(winPtr);
}
bool nuiWindowManager::DispatchMouseClick(const nglMouseInfo& rInfo)
{
if (!IsEnabled())
return false;
if (IsInsideFromRoot(rInfo.X, rInfo.Y))
{
if (!mWindows.empty())
{
std::list<nuiWindow*>::iterator it;
std::list<nuiWindow*>::iterator begin = mWindows.begin();
it = mWindows.end();
do
{
it--;
nuiWindow* win = *it;
if (win->IsInsideFromRoot(rInfo.X, rInfo.Y))
{
if (GetActiveWindow() != win)
ActivateWindow(win);
break;
}
} while (it!=begin);
}
IteratorPtr pIt;
for (pIt = GetLastChild(); pIt && pIt->IsValid(); GetPreviousChild(pIt))
{
nuiWidgetPtr pItem = pIt->GetWidget();
if (pItem && pItem->IsVisible() && pItem->IsEnabled())
{
if (pItem->DispatchMouseClick(rInfo))
{
delete pIt;
return true;
}
}
}
delete pIt;
nglMouseInfo info(rInfo);
GlobalToLocal(info.X, info.Y);
bool ret = MouseClicked(info);
ret |= Clicked(info);
return ret;
}
return false;
}
/* $ 29.12.2000 IS
Аналог CloseAll, но разрешает продолжение полноценной работы в фаре,
если пользователь продолжил редактировать файл.
Возвращает TRUE, если все закрыли и можно выходить из фара.
*/
BOOL Manager::ExitAll()
{
_MANAGER(CleverSysLog clv(L"Manager::ExitAll()"));
// BUGBUG don't use iterators here, may be invalidated by DeleteCommit()
for(size_t i = m_modalWindows.size(); i; --i)
{
if (i - 1 >= m_modalWindows.size())
continue;
auto CurrentWindow = m_modalWindows[i - 1];
if (!CurrentWindow->GetCanLoseFocus(TRUE))
{
auto PrevWindowCount = m_modalWindows.size();
CurrentWindow->ProcessKey(Manager::Key(KEY_ESC));
Commit();
if (PrevWindowCount == m_modalWindows.size())
{
return FALSE;
}
}
}
// BUGBUG don't use iterators here, may be invalidated by DeleteCommit()
for(size_t i = m_windows.size(); i; --i)
{
if (i - 1 >= m_windows.size())
continue;
auto CurrentWindow = m_windows[i - 1];
if (!CurrentWindow->GetCanLoseFocus(TRUE))
{
ActivateWindow(CurrentWindow);
Commit();
auto PrevWindoowCount = m_windows.size();
CurrentWindow->ProcessKey(Manager::Key(KEY_ESC));
Commit();
if (PrevWindoowCount == m_windows.size())
{
return FALSE;
}
}
}
return TRUE;
}
void ShowDialog(Dialog dialog) {
InitializeDialogProperties();
auto it = dialog_properties.find(dialog);
if (it != dialog_properties.end()) {
if (it->second.dialog) {
if (!it->second.dialog->IsWindow()) {
it->second.dialog->Create(it->second.resource_id,
GetWindowHandle(it->second.parent),
it->second.modal);
} else {
ActivateWindow(it->second.dialog->GetWindowHandle());
}
}
}
}
// Show about requester
void font_show_about(font_data *data)
{
struct EasyStruct easy;
// Window open?
if (data->about)
{
WindowToFront(data->about);
ActivateWindow(data->about);
return;
}
// Fill out easy struct
easy.es_StructSize=sizeof(easy);
easy.es_Flags=0;
easy.es_Title=0;
easy.es_TextFormat="Directory Opus 5 Font Viewer\nv55.0 (01.08.96)\n\n© 1996 Jonathan Potter";
easy.es_GadgetFormat=GetString(&data->locale,MSG_OK);
// Open requester
data->about=BuildEasyRequest(data->window,&easy,0,0);
}
short LIBFUNC L_Config_Filetypes(
REG(a0, struct Screen *screen),
REG(a1, IPCData *ipc),
REG(a2, IPCData *owner_ipc),
REG(d0, ULONG command_list),
REG(a3, char *name))
{
config_filetypes_data *data;
IPCMessage *quit_msg=0;
short undo_flag=0,pending_quit=0;
short ret=0,fontsize;
struct IBox pos;
ConfigWindow dims;
// Allocate data and memory handle
if (!(data=AllocVec(sizeof(config_filetypes_data),MEMF_CLEAR)) ||
!(data->memory=NewMemHandle(4096,256,MEMF_CLEAR)))
return 0;
// Save pointers
data->ipc=ipc;
data->owner_ipc=owner_ipc;
data->command_list=command_list;
// Initialise data
NewList(&data->list_list);
InitListLock(&data->proc_list,0);
// Fill in new window
data->newwin.parent=screen;
data->newwin.dims=&dims;
data->newwin.title=GetString(locale,MSG_FILETYPES_TITLE);
data->newwin.locale=locale;
data->newwin.flags=WINDOW_SCREEN_PARENT|WINDOW_VISITOR|WINDOW_REQ_FILL|WINDOW_AUTO_KEYS|WINDOW_SIZE_BOTTOM;
// Get default size
dims=_config_filetypes_window;
// Get saved position
if (LoadPos("dopus/windows/filetypes",&pos,&fontsize))
{
dims.char_dim.Width=0;
dims.char_dim.Height=0;
dims.fine_dim.Width=pos.Width;
dims.fine_dim.Height=pos.Height;
}
// Open window and add objects
if (!(data->window=OpenConfigWindow(&data->newwin)) ||
!(data->objlist=AddObjectList(data->window,_config_filetypes_objects)))
{
CloseConfigWindow(data->window);
FreeMemHandle(data->memory);
FreeVec(data);
return 0;
}
// Set minimum size
SetConfigWindowLimits(data->window,&_config_filetypes_window,0);
// Read filetype list
SetWindowBusy(data->window);
filetype_read_list(data->memory,&data->list_list);
// Build display list
filetype_build_list(data);
ClearWindowBusy(data->window);
// Name to edit?
if (name) filetype_edit_name(data,name);
// Event loop
FOREVER
{
struct IntuiMessage *msg;
IPCMessage *imsg;
int quit_flag=0;
// Any IPC messages?
while ((imsg=(IPCMessage *)GetMsg(ipc->command_port)))
{
// Look at command
switch (imsg->command)
{
// Quit
case IPC_QUIT:
quit_flag=1;
quit_msg=imsg;
imsg=0;
data->change=0;
break;
// Activate
case IPC_ACTIVATE:
if (data->window)
{
// Bring window to front
WindowToFront(data->window);
ActivateWindow(data->window);
// Edit name supplied?
if (imsg->data) filetype_edit_name(data,(char *)imsg->data);
}
break;
// Process saying goodbye
case IPC_GOODBYE:
{
FiletypeNode *node;
// Handle goodbye
if ((node=(FiletypeNode *)IPC_GetGoodbye(imsg)))
{
// Node no longer has an editor
node->editor=0;
}
// All process gone and pending quit?
if (pending_quit && (IsListEmpty(&data->proc_list.list)))
{
quit_flag=1;
pending_quit=2;
}
}
break;
// Got a filetype back from the editor
case FILETYPEEDIT_RETURN:
if (filetype_receive_edit(
data,
(Cfg_Filetype *)imsg->flags,
(FiletypeNode *)imsg->data))
{
data->change=1;
imsg->command=1;
}
else imsg->command=0;
break;
}
// Reply message
IPC_Reply(imsg);
// Check quit flag
if (quit_flag) break;
}
// Intuimessages
if (data->window)
{
while ((msg=GetWindowMsg(data->window->UserPort)))
{
struct IntuiMessage msg_copy;
UWORD id;
// Copy message and reply
msg_copy=*msg;
ReplyWindowMsg(msg);
if (pending_quit) continue;
// Look at message
switch (msg_copy.Class)
{
// Close window
case IDCMP_CLOSEWINDOW:
quit_flag=1;
undo_flag=1;
break;
// Gadget
case IDCMP_GADGETUP:
id=((struct Gadget *)msg_copy.IAddress)->GadgetID;
switch (id)
{
// Cancel
case GAD_FILETYPES_CANCEL:
undo_flag=1;
// Use
case GAD_FILETYPES_USE:
quit_flag=1;
break;
// Filetype selected
case GAD_FILETYPES_LIST:
{
Att_Node *node;
// Enable buttons
filetype_able_buttons(data,FALSE);
// Get selection
if (!(node=Att_FindNode(data->filetype_list,msg_copy.Code)))
break;
// Double-click?
if (node==data->sel_filetype &&
DoubleClick(
data->seconds,data->micros,
msg_copy.Seconds,msg_copy.Micros))
{
// Launch editor for this filetype
filetype_edit(data,(FiletypeNode *)data->sel_filetype->data,0);
}
// New selection
else
{
data->sel_filetype=node;
data->seconds=msg_copy.Seconds;
data->micros=msg_copy.Micros;
}
}
break;
// Add a new filetype
case GAD_FILETYPES_DUPLICATE:
if (!data->sel_filetype) break;
case GAD_FILETYPES_ADD:
{
Cfg_FiletypeList *list;
Cfg_Filetype *type=0;
// Allocate a new filetype list
if ((list=AllocMemH(data->memory,sizeof(Cfg_FiletypeList))))
{
// Initialise list
NewList(&list->filetype_list);
// Copy existing filetype?
if ((((struct Gadget *)msg_copy.IAddress)->GadgetID==
GAD_FILETYPES_DUPLICATE))
{
// Copy filetype
type=CopyFiletype(
((FiletypeNode *)data->sel_filetype->data)->type,
data->memory);
}
// Allocate a new filetype
else if ((type=NewFiletype(data->memory)))
{
// Initialise name
strcpy(type->type.name,GetString(locale,MSG_UNTITLED));
}
// Get a filetype?
if (type)
{
// Add filetype list to main list
AddTail(&data->list_list,&list->node);
// Add filetype to list
AddTail(&list->filetype_list,&type->node);
// Set list pointer
type->list=list;
list->flags=FTLISTF_CHANGED;
}
// Failed
else FreeMemH(list);
}
// Got new filetype?
if (type)
{
Att_Node *node;
// Remove existing list
SetGadgetChoices(
data->objlist,
GAD_FILETYPES_LIST,
(APTR)~0);
// Add entry for this filetype
node=filetype_add_entry(data,type);
// Handle new nodes
filetype_new_node(data,node);
}
}
break;
// Edit filetype
case GAD_FILETYPES_EDIT:
// Valid selection?
if (data->sel_filetype)
{
// Launch editor for this filetype
filetype_edit(data,(FiletypeNode *)data->sel_filetype->data,0);
}
break;
// Remove/Store
case GAD_FILETYPES_REMOVE:
case GAD_FILETYPES_STORE:
// Valid selection?
if (data->sel_filetype)
{
short ret;
// Remove filetype
if ((ret=
filetype_remove(
data,
data->sel_filetype,
(id==GAD_FILETYPES_STORE)))==1)
{
data->change=1;
data->sel_filetype=0;
}
// Quit?
else if (ret==-1)
{
quit_flag=1;
}
}
break;
}
break;
// Key press
case IDCMP_RAWKEY:
// Help?
if (msg_copy.Code==0x5f &&
!(msg_copy.Qualifier&VALID_QUALIFIERS))
{
// Set busy pointer
SetWindowBusy(data->window);
// Send help command
IPC_Command(data->owner_ipc,IPC_HELP,(1<<31),"File Types",0,REPLY_NO_PORT);
// Clear busy pointer
ClearWindowBusy(data->window);
}
break;
}
// Check quit flag
if (quit_flag) break;
}
}
// Check quit flag
if (quit_flag)
{
if (!pending_quit)
{
SetWindowBusy(data->window);
if (!(IPC_ListQuit(&data->proc_list,0,!undo_flag,FALSE)))
pending_quit=2;
else
pending_quit=1;
}
}
// Set to break?
if (pending_quit==2)
{
// Save filetypes?
if (data->change && !undo_flag)
{
if (!(ret=filetype_save(data)))
{
// Abort save/quit
ClearWindowBusy(data->window);
pending_quit=0;
continue;
}
}
break;
}
// Wait for an event
Wait(1<<ipc->command_port->mp_SigBit|
((data->window)?1<<data->window->UserPort->mp_SigBit:0));
}
// Save window position
if (data->window)
{
struct IBox pos;
pos.Left=data->window->LeftEdge;
pos.Top=data->window->TopEdge;
pos.Width=data->window->Width-data->window->BorderLeft-data->window->BorderRight;
pos.Height=data->window->Height-data->window->BorderTop-data->window->BorderBottom;
SavePos("dopus/windows/filetypes",(struct IBox *)&pos,data->window->RPort->TxHeight);
}
// Close up
CloseConfigWindow(data->window);
// Free data
Att_RemList(data->filetype_list,REMLIST_FREEDATA);
FreeMemHandle(data->memory);
FreeVec(data);
// Reply quit message
IPC_Reply(quit_msg);
return ret;
}
void ExecuteAction(std::wstring action, WPARAM wParam, LPARAM lParam) {
LOG(LevelDebug, action);
std::wstring body;
size_t pos = action.find('(');
if (pos != action.npos) {
body = action.substr(pos + 1, action.find_last_of(')') - (pos + 1));
action.resize(pos);
}
Trim(body);
Trim(action);
if (action.empty())
return;
//////////////////////////////////////////////////////////////////////////////
// Taiga
// CheckUpdates()
// Checks for a new version of the program.
if (action == L"CheckUpdates") {
ui::ShowDialog(ui::kDialogUpdate);
// Exit(), Quit()
// Exits from Taiga.
} else if (action == L"Exit" || action == L"Quit") {
ui::DlgMain.Destroy();
//////////////////////////////////////////////////////////////////////////////
// Services
// Synchronize()
// Synchronizes local and remote lists.
} else if (action == L"Synchronize") {
sync::Synchronize();
// SearchAnime()
// wParam is a BOOL value that defines local search.
} else if (action == L"SearchAnime") {
if (body.empty())
return;
bool local_search = wParam != FALSE;
if (!local_search) {
auto service = taiga::GetCurrentService();
if (service->RequestNeedsAuthentication(sync::kSearchTitle)) {
if (taiga::GetCurrentUsername().empty() ||
taiga::GetCurrentPassword().empty()) {
ui::OnSettingsAccountEmpty();
return;
}
}
}
ui::DlgMain.navigation.SetCurrentPage(ui::kSidebarItemSearch);
ui::DlgMain.edit.SetText(body);
ui::DlgSearch.Search(body, local_search);
// ViewAnimePage
// Opens up anime page on the active service.
// lParam is an anime ID.
} else if (action == L"ViewAnimePage") {
int anime_id = static_cast<int>(lParam);
switch (taiga::GetCurrentServiceId()) {
case sync::kMyAnimeList:
sync::myanimelist::ViewAnimePage(anime_id);
break;
case sync::kHummingbird:
sync::hummingbird::ViewAnimePage(anime_id);
break;
}
// ViewUpcomingAnime
// Opens up upcoming anime page on MAL.
} else if (action == L"ViewUpcomingAnime") {
switch (taiga::GetCurrentServiceId()) {
case sync::kMyAnimeList:
sync::myanimelist::ViewUpcomingAnime();
break;
case sync::kHummingbird:
sync::hummingbird::ViewUpcomingAnime();
break;
}
// MalViewPanel()
// MalViewProfile()
// MalViewHistory()
// Opens up MyAnimeList user pages.
} else if (action == L"MalViewPanel") {
sync::myanimelist::ViewPanel();
} else if (action == L"MalViewProfile") {
sync::myanimelist::ViewProfile();
} else if (action == L"MalViewHistory") {
sync::myanimelist::ViewHistory();
// HummingbirdViewProfile()
// HummingbirdViewDashboard()
// HummingbirdViewRecommendations()
// Opens up Hummingbird user pages.
} else if (action == L"HummingbirdViewProfile") {
sync::hummingbird::ViewProfile();
} else if (action == L"HummingbirdViewDashboard") {
sync::hummingbird::ViewDashboard();
} else if (action == L"HummingbirdViewRecommendations") {
sync::hummingbird::ViewRecommendations();
//////////////////////////////////////////////////////////////////////////////
// Execute(path)
// Executes a file or folder.
} else if (action == L"Execute") {
Execute(body);
// URL(address)
// Opens a web page.
// lParam is an anime ID.
} else if (action == L"URL") {
int anime_id = static_cast<int>(lParam);
auto anime_item = AnimeDatabase.FindItem(anime_id);
if (anime_item) {
std::wstring title = anime_item->GetTitle();
ReplaceString(body, L"%title%", EncodeUrl(title));
}
ExecuteLink(body);
//////////////////////////////////////////////////////////////////////////////
// UI
// About()
// Shows about window.
} else if (action == L"About") {
ui::ShowDialog(ui::kDialogAbout);
// Info([anime_id])
// Shows anime information window.
// lParam is an anime ID.
} else if (action == L"Info") {
int anime_id = body.empty() ? static_cast<int>(lParam) : ToInt(body);
ui::ShowDlgAnimeInfo(anime_id);
// MainDialog()
} else if (action == L"MainDialog") {
ui::ShowDialog(ui::kDialogMain);
// Settings()
// Shows settings window.
// wParam is the initial section.
// lParam is the initial page.
} else if (action == L"Settings") {
ui::ShowDlgSettings(wParam, lParam);
// SearchTorrents(source)
// Searches torrents from specified source URL.
// lParam is an anime ID.
} else if (action == L"SearchTorrents") {
int anime_id = static_cast<int>(lParam);
if (body.empty())
body = Settings[taiga::kTorrent_Discovery_SearchUrl];
ui::DlgTorrent.Search(body, anime_id);
// ToggleSidebar()
} else if (action == L"ToggleSidebar") {
bool hide_sidebar = Settings.Toggle(taiga::kApp_Option_HideSidebar);
ui::DlgMain.treeview.Show(!hide_sidebar);
ui::DlgMain.UpdateControlPositions();
ui::Menus.UpdateView();
// TorrentAddFilter()
// Shows add new filter window.
// wParam is a BOOL value that represents modal status.
// lParam is the handle of the parent window.
} else if (action == L"TorrentAddFilter") {
if (!ui::DlgFeedFilter.IsWindow()) {
ui::DlgFeedFilter.Create(IDD_FEED_FILTER,
reinterpret_cast<HWND>(lParam), wParam != FALSE);
} else {
ActivateWindow(ui::DlgFeedFilter.GetWindowHandle());
}
// ViewContent(page)
// Selects a page from sidebar.
} else if (action == L"ViewContent") {
int page = ToInt(body);
ui::DlgMain.navigation.SetCurrentPage(page);
//////////////////////////////////////////////////////////////////////////////
// Library
// AddToList(status)
// Adds an anime to list with given status.
// wParam is a BOOL value that defines lParam.
// lParam is an anime ID, or a pointer to a vector of anime IDs.
} else if (action == L"AddToList") {
int status = ToInt(body);
if (!wParam) {
int anime_id = static_cast<int>(lParam);
AnimeDatabase.AddToList(anime_id, status);
} else {
const auto& anime_ids = *reinterpret_cast<std::vector<int>*>(lParam);
for (const auto& anime_id : anime_ids) {
AnimeDatabase.AddToList(anime_id, status);
}
}
// ClearHistory()
// Deletes all history items.
} else if (action == L"ClearHistory") {
if (ui::OnHistoryClear())
History.Clear();
//////////////////////////////////////////////////////////////////////////////
// Tracker
// AddFolder()
// Opens up a dialog to add new library folder.
} else if (action == L"AddFolder") {
std::wstring path;
if (win::BrowseForFolder(ui::GetWindowHandle(ui::kDialogMain),
L"Add a Library Folder", L"", path)) {
Settings.library_folders.push_back(path);
if (Settings.GetBool(taiga::kLibrary_WatchFolders))
FolderMonitor.Enable();
ui::ShowDlgSettings(ui::kSettingsSectionLibrary, ui::kSettingsPageLibraryFolders);
}
// ScanEpisodes(), ScanEpisodesAll()
// Checks episode availability.
} else if (action == L"ScanEpisodes") {
int anime_id = static_cast<int>(lParam);
ScanAvailableEpisodes(false, anime_id, 0);
} else if (action == L"ScanEpisodesAll") {
ScanAvailableEpisodes(false);
//////////////////////////////////////////////////////////////////////////////
// Settings
// ToggleRecognition()
// Enables or disables anime recognition.
} else if (action == L"ToggleRecognition") {
bool enable_recognition = Settings.Toggle(taiga::kApp_Option_EnableRecognition);
if (enable_recognition) {
ui::ChangeStatusText(L"Automatic anime recognition is now enabled.");
CurrentEpisode.Set(anime::ID_UNKNOWN);
} else {
ui::ChangeStatusText(L"Automatic anime recognition is now disabled.");
auto anime_item = AnimeDatabase.FindItem(CurrentEpisode.anime_id);
CurrentEpisode.Set(anime::ID_NOTINLIST);
if (anime_item)
EndWatching(*anime_item, CurrentEpisode);
}
// ToggleSharing()
// Enables or disables automatic sharing.
} else if (action == L"ToggleSharing") {
bool enable_sharing = Settings.Toggle(taiga::kApp_Option_EnableSharing);
ui::Menus.UpdateTools();
if (enable_sharing) {
ui::ChangeStatusText(L"Automatic sharing is now enabled.");
} else {
ui::ChangeStatusText(L"Automatic sharing is now disabled.");
}
// ToggleSynchronization()
// Enables or disables automatic list synchronization.
} else if (action == L"ToggleSynchronization") {
bool enable_sync = Settings.Toggle(taiga::kApp_Option_EnableSync);
ui::Menus.UpdateTools();
if (enable_sync) {
ui::ChangeStatusText(L"Automatic synchronization is now enabled.");
} else {
ui::ChangeStatusText(L"Automatic synchronization is now disabled.");
}
//////////////////////////////////////////////////////////////////////////////
// Sharing
// AnnounceToHTTP(force)
// Sends an HTTP request.
} else if (action == L"AnnounceToHTTP") {
Announcer.Do(taiga::kAnnounceToHttp, nullptr, body == L"true");
// AnnounceToMIRC(force)
// Sends message to specified channels in mIRC.
} else if (action == L"AnnounceToMIRC") {
Announcer.Do(taiga::kAnnounceToMirc, nullptr, body == L"true");
// AnnounceToSkype(force)
// Changes Skype mood text.
// Requires authorization.
} else if (action == L"AnnounceToSkype") {
Announcer.Do(taiga::kAnnounceToSkype, nullptr, body == L"true");
// AnnounceToTwitter(force)
// Changes Twitter status.
} else if (action == L"AnnounceToTwitter") {
Announcer.Do(taiga::kAnnounceToTwitter, nullptr, body == L"true");
//////////////////////////////////////////////////////////////////////////////
// EditAll([anime_id])
// Shows a dialog to edit details of an anime.
// lParam is an anime ID.
} else if (action == L"EditAll") {
int anime_id = body.empty() ? static_cast<int>(lParam) : ToInt(body);
ui::ShowDlgAnimeEdit(anime_id);
// EditDelete()
// Removes an anime from list.
// lParam is a pointer to a vector of anime IDs.
} else if (action == L"EditDelete") {
const auto& anime_ids = *reinterpret_cast<std::vector<int>*>(lParam);
if (ui::OnLibraryEntriesEditDelete(anime_ids)) {
for (const auto& anime_id : anime_ids) {
HistoryItem history_item;
history_item.anime_id = anime_id;
history_item.mode = taiga::kHttpServiceDeleteLibraryEntry;
History.queue.Add(history_item);
}
}
// EditEpisode()
// Changes watched episode value of an anime.
// lParam is a pointer to a vector of anime IDs.
} else if (action == L"EditEpisode") {
const auto& anime_ids = *reinterpret_cast<std::vector<int>*>(lParam);
int value = ui::OnLibraryEntriesEditEpisode(anime_ids);
if (value > -1) {
for (const auto& anime_id : anime_ids) {
anime::ChangeEpisode(anime_id, value);
}
}
// DecrementEpisode()
// lParam is an anime ID.
} else if (action == L"DecrementEpisode") {
int anime_id = static_cast<int>(lParam);
anime::DecrementEpisode(anime_id);
// IncrementEpisode()
// lParam is an anime ID.
} else if (action == L"IncrementEpisode") {
int anime_id = static_cast<int>(lParam);
anime::IncrementEpisode(anime_id);
// EditScore(value)
// Changes anime score.
// Value must be between 0-10 and different from current score.
// lParam is a pointer to a vector of anime IDs.
} else if (action == L"EditScore") {
const auto& anime_ids = *reinterpret_cast<std::vector<int>*>(lParam);
for (const auto& anime_id : anime_ids) {
HistoryItem history_item;
history_item.anime_id = anime_id;
history_item.score = ToInt(body);
history_item.mode = taiga::kHttpServiceUpdateLibraryEntry;
History.queue.Add(history_item);
}
// EditStatus(value)
// Changes anime status of user.
// Value must be 1, 2, 3, 4 or 5, and different from current status.
// lParam is a pointer to a vector of anime IDs.
} else if (action == L"EditStatus") {
const auto& anime_ids = *reinterpret_cast<std::vector<int>*>(lParam);
for (const auto& anime_id : anime_ids) {
HistoryItem history_item;
history_item.status = ToInt(body);
auto anime_item = AnimeDatabase.FindItem(anime_id);
if (!anime_item)
continue;
switch (*history_item.status) {
case anime::kCompleted:
history_item.episode = anime_item->GetEpisodeCount();
if (*history_item.episode == 0)
history_item.episode.Reset();
if (!anime::IsValidDate(anime_item->GetMyDateStart()) &&
anime_item->GetEpisodeCount() == 1)
history_item.date_start = GetDate();
if (!anime::IsValidDate(anime_item->GetMyDateEnd()))
history_item.date_finish = GetDate();
break;
}
history_item.anime_id = anime_id;
history_item.mode = taiga::kHttpServiceUpdateLibraryEntry;
History.queue.Add(history_item);
}
// EditTags(tags)
// Changes anime tags.
// Tags must be separated by a comma.
// lParam is a pointer to a vector of anime IDs.
} else if (action == L"EditTags") {
const auto& anime_ids = *reinterpret_cast<std::vector<int>*>(lParam);
std::wstring tags;
if (ui::OnLibraryEntriesEditTags(anime_ids, tags)) {
for (const auto& anime_id : anime_ids) {
HistoryItem history_item;
history_item.anime_id = anime_id;
history_item.tags = tags;
history_item.mode = taiga::kHttpServiceUpdateLibraryEntry;
History.queue.Add(history_item);
}
}
//////////////////////////////////////////////////////////////////////////////
// OpenFolder()
// Searches for anime folder and opens it.
// lParam is an anime ID.
} else if (action == L"OpenFolder") {
int anime_id = static_cast<int>(lParam);
auto anime_item = AnimeDatabase.FindItem(anime_id);
if (!anime_item || !anime_item->IsInList())
return;
if (!anime::ValidateFolder(*anime_item))
ScanAvailableEpisodes(false, anime_item->GetId(), 0);
if (anime_item->GetFolder().empty()) {
if (ui::OnAnimeFolderNotFound()) {
std::wstring default_path, path;
if (!Settings.library_folders.empty())
default_path = Settings.library_folders.front();
if (win::BrowseForFolder(ui::GetWindowHandle(ui::kDialogMain),
L"Select Anime Folder",
default_path, path)) {
anime_item->SetFolder(path);
Settings.Save();
}
}
}
ui::ClearStatusText();
if (!anime_item->GetFolder().empty()) {
Execute(anime_item->GetFolder());
}
//////////////////////////////////////////////////////////////////////////////
// PlayEpisode(value)
// Searches for an episode of an anime and plays it.
// lParam is an anime ID.
} else if (action == L"PlayEpisode") {
int number = ToInt(body);
int anime_id = static_cast<int>(lParam);
anime::PlayEpisode(anime_id, number);
// PlayLast()
// Searches for the last watched episode of an anime and plays it.
// lParam is an anime ID.
} else if (action == L"PlayLast") {
int anime_id = static_cast<int>(lParam);
anime::PlayLastEpisode(anime_id);
// PlayNext([anime_id])
// Searches for the next episode of an anime and plays it.
// lParam is an anime ID.
} else if (action == L"PlayNext") {
int anime_id = body.empty() ? static_cast<int>(lParam) : ToInt(body);
if (anime::IsValidId(anime_id)) {
anime::PlayNextEpisode(anime_id);
} else {
anime::PlayNextEpisodeOfLastWatchedAnime();
}
// PlayRandom()
// Searches for a random episode of an anime and plays it.
// lParam is an anime ID.
} else if (action == L"PlayRandom") {
int anime_id = body.empty() ? static_cast<int>(lParam) : ToInt(body);
anime::PlayRandomEpisode(anime_id);
// PlayRandomAnime()
// Searches for a random episode of a random anime and plays it.
} else if (action == L"PlayRandomAnime") {
anime::PlayRandomAnime();
//////////////////////////////////////////////////////////////////////////////
// Season_Load(file)
// Loads season data.
} else if (action == L"Season_Load") {
if (SeasonDatabase.Load(body)) {
SeasonDatabase.Review();
ui::DlgSeason.RefreshList();
ui::DlgSeason.RefreshStatus();
ui::DlgSeason.RefreshToolbar();
if (SeasonDatabase.IsRefreshRequired())
if (ui::OnSeasonRefreshRequired())
ui::DlgSeason.RefreshData();
}
// Season_GroupBy(group)
// Groups season data.
} else if (action == L"Season_GroupBy") {
ui::DlgSeason.group_by = ToInt(body);
ui::DlgSeason.RefreshList();
ui::DlgSeason.RefreshToolbar();
// Season_SortBy(sort)
// Sorts season data.
} else if (action == L"Season_SortBy") {
ui::DlgSeason.sort_by = ToInt(body);
ui::DlgSeason.RefreshList();
ui::DlgSeason.RefreshToolbar();
// Season_RefreshItemData()
// Refreshes an individual season item data.
// lParam is a pointer to a vector of anime IDs.
} else if (action == L"Season_RefreshItemData") {
const auto& anime_ids = *reinterpret_cast<std::vector<int>*>(lParam);
for (const auto& anime_id : anime_ids) {
ui::DlgSeason.RefreshData(anime_id);
}
// Season_ViewAs(mode)
// Changes view mode.
} else if (action == L"Season_ViewAs") {
ui::DlgSeason.SetViewMode(ToInt(body));
ui::DlgSeason.RefreshList();
ui::DlgSeason.RefreshToolbar();
// Unknown
} else {
LOG(LevelWarning, L"Unknown action: " + action);
}
}
void SAVEDS PaletteBox(void)
{
PaletteBoxData *data;
struct Window *window;
IPCData *ipc;
// Do startup
if (!(ipc=Local_IPC_ProcStartup((ULONG *)&data,0)))
{
Forbid();
return;
}
// Get pen count
data->pen_count=data->screen_data.pen_count;
// Open window
if ((window=palette_box_open(data,data->stuff.stuff1.object_def,data->pen_array,data->pen_array)))
{
// Event loop
FOREVER
{
struct IntuiMessage *msg;
IPCMessage *imsg;
short break_flag=0;
// IPC messages
while ((imsg=(IPCMessage *)GetMsg(ipc->command_port)))
{
switch (imsg->command)
{
// Quit
case IPC_QUIT:
break_flag=1;
break;
// Activate
case IPC_ACTIVATE:
if (window)
{
WindowToFront(window);
ActivateWindow(window);
}
break;
// Hide
case IPC_HIDE:
CloseConfigWindow(window);
window=0;
break;
// Show
case IPC_SHOW:
data->newwin.parent=(void *)imsg->data;
if (!(window=palette_box_open(data,data->stuff.stuff1.object_def,data->pen_array,data->pen_array)))
break_flag=1;
break;
}
IPC_Reply(imsg);
}
// Intuition messages
if (window)
{
while ((msg=GetWindowMsg(window->UserPort)))
{
struct IntuiMessage msg_copy;
msg_copy=*msg;
ReplyWindowMsg(msg);
// Close
if (msg_copy.Class==IDCMP_CLOSEWINDOW)
break_flag=1;
// Gadget
else
if (msg_copy.Class==IDCMP_GADGETUP)
{
short fg,bg;
// Get foreground and background colours
fg=GetGadgetValue(OBJLIST(window),GAD_PALETTE_FOREGROUND);
bg=GetGadgetValue(OBJLIST(window),GAD_PALETTE_BACKGROUND);
// Fix pens
if (((struct Library*)IntuitionBase)->lib_Version>=39)
{
if (fg>=4 && fg<8) fg=248+fg;
else
if (fg>7) fg-=4;
if (bg>=4 && bg<8) bg=248+bg;
else
if (bg>7) bg-=4;
}
data->fgpen=fg;
data->bgpen=bg;
// Send new colours
IPC_Command(
data->owner_ipc,
BUTTONEDIT_NEW_COLOURS,
data->fgpen,
(APTR)data->bgpen,
0,
0);
}
// Key
else
if (msg_copy.Class==IDCMP_RAWKEY)
{
// Help?
if (msg_copy.Code==0x5f &&
!(msg_copy.Qualifier&VALID_QUALIFIERS))
{
// Set busy pointer
SetWindowBusy(window);
// Send help command
IPC_Command(data->main_ipc,IPC_HELP,(1<<31),"Select Colours",0,REPLY_NO_PORT);
// Clear busy pointer
ClearWindowBusy(window);
}
}
}
}
if (break_flag) break;
Wait(1<<ipc->command_port->mp_SigBit|
((window)?1<<window->UserPort->mp_SigBit:0));
}
CloseConfigWindow(window);
}
void desktop_drop(BackdropInfo *info,DOpusAppMessage *msg,UWORD qual)
{
BackdropObject *drop_obj;
short ok=0,x,y;
char *name,*source_path;
short arg,action=DESKTOP_POPUP_LEFTOUT;
struct ArgArray *array=0;
struct ArgArrayEntry *aae;
BOOL check;
// Lock backdrop list
lock_listlock(&info->objects,0);
// See if we dropped stuff on an object
if ((drop_obj=backdrop_get_object(info,msg->da_Msg.am_MouseX,msg->da_Msg.am_MouseY,0)))
{
// Is shift/alt down?
if ((qual&(IEQUALIFIER_LSHIFT|IEQUALIFIER_LALT))==(IEQUALIFIER_LSHIFT|IEQUALIFIER_LALT))
{
char pathname[256];
// Get path of first file
GetWBArgPath(&msg->da_Msg.am_ArgList[0],pathname,256);
// Replace the image
backdrop_replace_icon_image(info,pathname,drop_obj);
// Reply the message
ReplyAppMessage(msg);
}
// Handle drop on an object
else
if (desktop_drop_on_object(info,&msg,drop_obj,qual))
{
// Reply the message
ReplyAppMessage(msg);
}
// Not dropped
else drop_obj=0;
}
// Unlock backdrop list
unlock_listlock(&info->objects);
// Dropped on an object?
if (drop_obj) return;
// Get buffer
if (!(name=AllocVec(1024,MEMF_CLEAR))) return;
source_path=name+512;
// Popup menu?
if (environment->env->env_flags&ENVF_DESKTOP_FOLDER)
{
UWORD res;
// Activate the underlying menu
ActivateWindow(info->window);
// Default action set?
if (environment->env->desktop_popup_default>DESKTOP_POPUP_NONE &&
!(qual&(IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)))
{
// Use default action
action=environment->env->desktop_popup_default;
}
// Ask user what they want to do
else
if ((res=DoPopUpMenu(info->window,&GUI->desktop_menu->ph_Menu,0,SELECTDOWN))==(UWORD)-1 || res==MENU_DESKTOP_CANCEL)
{
// Cancelled
FreeVec(name);
return;
}
// Help?
else
if (res&POPUP_HELPFLAG)
{
// Do help
help_menu_help(res&~POPUP_HELPFLAG,0);
// Cancelled
FreeVec(name);
return;
}
// Get action
else
if (res==MENU_DESKTOP_COPY) action=DESKTOP_POPUP_COPY;
else
if (res==MENU_DESKTOP_MOVE) action=DESKTOP_POPUP_MOVE;
}
// Set busy pointer
SetBusyPointer(info->window);
// DOpus message?
check=CheckAppMessage(msg);
// Go through arguments
for (arg=0;arg<msg->da_Msg.am_NumArgs;arg++)
{
// What operation?
switch (action)
{
// Leave out?
case DESKTOP_POPUP_LEFTOUT:
// Get path name
GetWBArgPath(&msg->da_Msg.am_ArgList[arg],name,512);
// Ignore if it's an icon or a disk
if (!(isicon(name)) && name[strlen(name)-1]!=':')
{
short len,perm=0;
BackdropObject *icon;
// Permanent?
if (GUI->flags2&GUIF2_BENIFY)
perm=1;
// Get position
x=msg->da_Msg.am_MouseX;
y=msg->da_Msg.am_MouseY;
// Drop from DOpus?
if (check)
{
// Adjust position for icon offset
x+=msg->da_DragOffset.x+msg->da_DropPos[arg].x;
y+=msg->da_DragOffset.y+msg->da_DropPos[arg].y;
}
// Strip trailing /
len=strlen(name)-1;
if (name[len]=='/') name[len]=0;
// Leave this out
if ((icon=backdrop_leave_out(info,name,(perm)?BLOF_PERMANENT:0,x,y)))
{
// Position it
backdrop_place_object(info,icon);
// Save for permanent leftout
if (perm) backdrop_save_leftouts(info);
ok=1;
}
}
break;
// Copy/Move
case DESKTOP_POPUP_COPY:
case DESKTOP_POPUP_MOVE:
{
BOOL dir=0;
// Create ArgArray if needed
if (!array &&
!(array=NewArgArray())) break;
// Get path name
GetWBArgPath(&msg->da_Msg.am_ArgList[arg],name,512);
// Set flag if a directory
if (!msg->da_Msg.am_ArgList[arg].wa_Name ||
!*msg->da_Msg.am_ArgList[arg].wa_Name) dir=1;
// Get source path
if (!*source_path)
{
char *ptr;
// Copy from name
strcpy(source_path,name);
// Strip last part
if ((ptr=FilePart(source_path))) *ptr=0;
}
// Create argument
if ((aae=NewArgArrayEntry(array,FilePart(name))))
{
// Set directory flag
if (dir) aae->ae_Flags|=AEF_DIR;
// Set OK flag
ok=1;
}
}
break;
}
}
// Successful?
if (ok)
{
// Left-outs?
if (action==DESKTOP_POPUP_LEFTOUT)
{
// Refresh
backdrop_show_objects(info,BDSF_RECALC);
}
// Otherwise, launch function
else
{
// Launch the function
function_launch(
FUNCTION_RUN_FUNCTION_EXTERNAL,
(action==DESKTOP_POPUP_COPY)?def_function_copy:def_function_move,
0,
FUNCF_ICONS|FUNCF_RESCAN_DESKTOP|FUNCF_DRAG_DROP|FUNCF_COPY_NO_MOVE,
0,0,
source_path,environment->env->desktop_location,
array,
0,
(Buttons *)CopyAppMessage(msg,global_memory_pool));
}
}
// Otherwise, free array
else FreeArgArray(array);
// Free buffer
FreeVec(name);
// Clear busy pointer
ClearPointer(info->window);
// Reply the message
ReplyAppMessage(msg);
}
void DrawMessageWindow (MessageWindow* messageWindow, char *title, char **msg, int length)
{
FcitxLightUI* lightui = messageWindow->owner;
Display *dpy = lightui->dpy;
int i = 0;
if (title)
{
if (messageWindow->title)
free(messageWindow->title);
messageWindow->title = strdup(title);
}
else
if (!messageWindow->title)
return;
title = messageWindow->title;
FcitxLog(DEBUG, "%s", title);
XTextProperty tp;
Xutf8TextListToTextProperty(dpy, &title, 1, XUTF8StringStyle, &tp);
XSetWMName(dpy, messageWindow->window, &tp);
XFree(tp.value);
if (msg)
{
if (messageWindow->msg)
{
for (i =0 ;i<messageWindow->length; i++)
free(messageWindow->msg[i]);
free(messageWindow->msg);
}
messageWindow->length = length;
messageWindow->msg = malloc(sizeof(char*) * length);
for (i = 0; i < messageWindow->length; i++)
messageWindow->msg[i] = strdup(msg[i]);
}
else
{
if (!messageWindow->msg)
return;
}
msg = messageWindow->msg;
length = messageWindow->length;
if (!msg || length == 0)
return;
messageWindow->height = MESSAGE_WINDOW_MARGIN * 2 + length *(messageWindow->fontSize + MESSAGE_WINDOW_LINESPACE);
messageWindow->width = 0;
for (i = 0; i< length ;i ++)
{
int width;
if (width > messageWindow->width)
messageWindow->width = width;
}
messageWindow->width += MESSAGE_WINDOW_MARGIN * 2;
XResizeWindow(dpy, messageWindow->window, messageWindow->width, messageWindow->height);
int x, y;
x = MESSAGE_WINDOW_MARGIN;
y = MESSAGE_WINDOW_MARGIN;
for (i = 0; i< length ;i ++)
{
y += messageWindow->fontSize + MESSAGE_WINDOW_LINESPACE;
}
ActivateWindow(dpy, lightui->iScreen, messageWindow->window);
}
void ami_open_tree(struct tree *tree,int type)
{
struct treeview_window *twin;
BOOL msel = TRUE,nothl = TRUE,launchdisable=FALSE;
static WORD gen=0;
char *wintitle;
char folderclosed[100],folderopen[100],item[100];
if(tree->handle)
{
twin = (struct treeview_window *)tree->handle;
WindowToFront(twin->win);
ActivateWindow(twin->win);
return;
}
twin = AllocVec(sizeof(struct treeview_window),MEMF_PRIVATE | MEMF_CLEAR);
twin->listbrowser_list = AllocVec(sizeof(struct List),MEMF_PRIVATE | MEMF_CLEAR);
static struct ColumnInfo columninfo[] =
{
{ 80,"Name", CIF_DRAGGABLE | CIF_SORTABLE},
{ 20,"URL", CIF_DRAGGABLE },
// { 5,"Visits", CIF_DRAGGABLE },
{ -1, (STRPTR)~0, -1 }
};
if(tree->single_selection) msel = FALSE;
ami_get_theme_filename(&folderclosed,"theme_list_folder_closed");
ami_get_theme_filename(&folderopen,"theme_list_folder_open");
switch(type)
{
case AMI_TREE_HOTLIST:
nothl = FALSE;
wintitle = (char *)messages_get("Hotlist");
ami_get_theme_filename(&item,"theme_list_bookmark");
break;
case AMI_TREE_COOKIES:
nothl = TRUE;
launchdisable=TRUE;
wintitle = (char *)messages_get("Cookies");
ami_get_theme_filename(&item,"theme_list_cookie");
break;
case AMI_TREE_HISTORY:
nothl = TRUE;
wintitle = (char *)messages_get("GlobalHistory");
ami_get_theme_filename(&item,"theme_list_history");
break;
case AMI_TREE_SSLCERT:
nothl = TRUE;
wintitle = (char *)messages_get("SSLCerts");
ami_get_theme_filename(&item,"theme_list_sslcert");
break;
}
NewList(twin->listbrowser_list);
tree->handle = (void *)twin;
twin->tree = tree;
ami_add_elements(twin,twin->tree->root,&gen);
twin->objects[OID_MAIN] = WindowObject,
WA_ScreenTitle,nsscreentitle,
WA_Title,wintitle,
WA_Activate, TRUE,
WA_DepthGadget, TRUE,
WA_DragBar, TRUE,
WA_CloseGadget, TRUE,
WA_SizeGadget, TRUE,
WA_CustomScreen,scrn,
WINDOW_SharedPort,sport,
WINDOW_UserData,twin,
WINDOW_IconifyGadget, TRUE,
WINDOW_Position, WPOS_CENTERSCREEN,
WINDOW_ParentGroup, twin->gadgets[GID_MAIN] = VGroupObject,
LAYOUT_AddChild, twin->gadgets[GID_TREEBROWSER] = ListBrowserObject,
GA_ID, GID_TREEBROWSER,
GA_RelVerify, TRUE,
GA_ReadOnly,FALSE,
LISTBROWSER_ColumnInfo, &columninfo,
// LISTBROWSER_ColumnTitles, TRUE,
LISTBROWSER_Hierarchical,TRUE,
LISTBROWSER_Editable,TRUE,
// LISTBROWSER_TitleClickable,TRUE,
LISTBROWSER_AutoFit, TRUE,
LISTBROWSER_HorizontalProp, TRUE,
LISTBROWSER_Labels, twin->listbrowser_list,
// LISTBROWSER_MultiSelect,msel,
LISTBROWSER_ShowSelected,TRUE,
LISTBROWSER_ShowImage,BitMapObject,
BITMAP_SourceFile,folderclosed,
BITMAP_Screen,scrn,
BITMAP_Masking,TRUE,
BitMapEnd,
LISTBROWSER_HideImage,BitMapObject,
BITMAP_SourceFile,folderopen,
BITMAP_Screen,scrn,
BITMAP_Masking,TRUE,
BitMapEnd,
LISTBROWSER_LeafImage,BitMapObject,
BITMAP_SourceFile,item,
BITMAP_Screen,scrn,
BITMAP_Masking,TRUE,
BitMapEnd,
ListBrowserEnd,
CHILD_NominalSize,TRUE,
LAYOUT_AddChild, HGroupObject,
LAYOUT_AddChild, twin->gadgets[GID_OPEN] = ButtonObject,
GA_ID,GID_OPEN,
GA_Text,messages_get("TreeLaunch"),
GA_RelVerify,TRUE,
GA_Disabled,launchdisable,
ButtonEnd,
LAYOUT_AddChild, twin->gadgets[GID_NEWF] = ButtonObject,
GA_ID,GID_NEWF,
BUTTON_AutoButton,BAG_POPDRAWER,
GA_RelVerify,TRUE,
GA_Disabled,nothl,
ButtonEnd,
LAYOUT_AddChild, twin->gadgets[GID_NEWB] = ButtonObject,
GA_ID,GID_NEWB,
BUTTON_AutoButton,BAG_POPFILE,
GA_RelVerify,TRUE,
GA_Disabled,nothl,
ButtonEnd,
LAYOUT_AddChild, twin->gadgets[GID_LEFT] = ButtonObject,
GA_ID,GID_LEFT,
BUTTON_AutoButton,BAG_LFARROW,
GA_RelVerify,TRUE,
GA_Disabled,nothl, //(!tree->movable),
ButtonEnd,
LAYOUT_AddChild, twin->gadgets[GID_UP] = ButtonObject,
GA_ID,GID_UP,
BUTTON_AutoButton,BAG_UPARROW,
GA_RelVerify,TRUE,
GA_Disabled,nothl, //(!tree->movable),
ButtonEnd,
LAYOUT_AddChild, twin->gadgets[GID_DOWN] = ButtonObject,
GA_ID,GID_DOWN,
BUTTON_AutoButton,BAG_DNARROW,
GA_RelVerify,TRUE,
GA_Disabled,nothl, //(!tree->movable),
ButtonEnd,
LAYOUT_AddChild, twin->gadgets[GID_DEL] = ButtonObject,
GA_ID,GID_DEL,
GA_Text,messages_get("TreeDelete"),
GA_RelVerify,TRUE,
ButtonEnd,
EndGroup,
CHILD_WeightedHeight,0,
EndGroup,
EndWindow;
twin->win = (struct Window *)RA_OpenWindow(twin->objects[OID_MAIN]);
twin->node = AddObject(window_list,AMINS_TVWINDOW);
twin->node->objstruct = twin;
}
int main(int argc, char **argv)
#endif
{
ll_init_apr();
// Set up llerror logging
{
LLError::initForApplication(".");
LLError::setDefaultLevel(LLError::LEVEL_INFO);
// LLError::setTagLevel("Plugin", LLError::LEVEL_DEBUG);
// LLError::logToFile("slplugin.log");
}
#if LL_WINDOWS
if( strlen( lpCmdLine ) == 0 )
{
LL_ERRS("slplugin") << "usage: " << "SLPlugin" << " launcher_port" << LL_ENDL;
};
U32 port = 0;
if(!LLStringUtil::convertToU32(lpCmdLine, port))
{
LL_ERRS("slplugin") << "port number must be numeric" << LL_ENDL;
};
// Insert our exception handler into the system so this plugin doesn't
// display a crash message if something bad happens. The host app will
// see the missing heartbeat and log appropriately.
initExceptionHandler();
#elif LL_DARWIN || LL_LINUX
if(argc < 2)
{
LL_ERRS("slplugin") << "usage: " << argv[0] << " launcher_port" << LL_ENDL;
}
U32 port = 0;
if(!LLStringUtil::convertToU32(argv[1], port))
{
LL_ERRS("slplugin") << "port number must be numeric" << LL_ENDL;
}
// Catch signals that most kinds of crashes will generate, and exit cleanly so the system crash dialog isn't shown.
signal(SIGILL, &crash_handler); // illegal instruction
# if LL_DARWIN
signal(SIGEMT, &crash_handler); // emulate instruction executed
# endif // LL_DARWIN
signal(SIGFPE, &crash_handler); // floating-point exception
signal(SIGBUS, &crash_handler); // bus error
signal(SIGSEGV, &crash_handler); // segmentation violation
signal(SIGSYS, &crash_handler); // non-existent system call invoked
#endif
#if LL_DARWIN
setupCocoa();
createAutoReleasePool();
#endif
LLPluginProcessChild *plugin = new LLPluginProcessChild();
plugin->init(port);
#if LL_DARWIN
deleteAutoReleasePool();
#endif
LLTimer timer;
timer.start();
#if LL_WINDOWS
checkExceptionHandler();
#endif
#if LL_DARWIN
// If the plugin opens a new window (such as the Flash plugin's fullscreen player), we may need to bring this plugin process to the foreground.
// Use this to track the current frontmost window and bring this process to the front if it changes.
WindowRef front_window = NULL;
WindowGroupRef layer_group = NULL;
int window_hack_state = 0;
CreateWindowGroup(kWindowGroupAttrFixedLevel, &layer_group);
if(layer_group)
{
// Start out with a window layer that's way out in front (fixes the problem with the menubar not getting hidden on first switch to fullscreen youtube)
SetWindowGroupName(layer_group, CFSTR("SLPlugin Layer"));
SetWindowGroupLevel(layer_group, kCGOverlayWindowLevel);
}
#endif
#if LL_DARWIN
EventTargetRef event_target = GetEventDispatcherTarget();
#endif
while(!plugin->isDone())
{
#if LL_DARWIN
createAutoReleasePool();
#endif
timer.reset();
plugin->idle();
#if LL_DARWIN
{
// Some plugins (webkit at least) will want an event loop. This qualifies.
EventRef event;
if(ReceiveNextEvent(0, 0, kEventDurationNoWait, true, &event) == noErr)
{
SendEventToEventTarget (event, event_target);
ReleaseEvent(event);
}
// Check for a change in this process's frontmost window.
if(FrontWindow() != front_window)
{
ProcessSerialNumber self = { 0, kCurrentProcess };
ProcessSerialNumber parent = { 0, kNoProcess };
ProcessSerialNumber front = { 0, kNoProcess };
Boolean this_is_front_process = false;
Boolean parent_is_front_process = false;
{
// Get this process's parent
ProcessInfoRec info;
info.processInfoLength = sizeof(ProcessInfoRec);
info.processName = NULL;
info.processAppSpec = NULL;
if(GetProcessInformation( &self, &info ) == noErr)
{
parent = info.processLauncher;
}
// and figure out whether this process or its parent are currently frontmost
if(GetFrontProcess(&front) == noErr)
{
(void) SameProcess(&self, &front, &this_is_front_process);
(void) SameProcess(&parent, &front, &parent_is_front_process);
}
}
if((FrontWindow() != NULL) && (front_window == NULL))
{
// Opening the first window
if(window_hack_state == 0)
{
// Next time through the event loop, lower the window group layer
window_hack_state = 1;
}
if(layer_group)
{
SetWindowGroup(FrontWindow(), layer_group);
}
if(parent_is_front_process)
{
// Bring this process's windows to the front.
(void) SetFrontProcess( &self );
}
ActivateWindow(FrontWindow(), true);
}
else if((FrontWindow() == NULL) && (front_window != NULL))
{
// Closing the last window
if(this_is_front_process)
{
// Try to bring this process's parent to the front
(void) SetFrontProcess(&parent);
}
}
else if(window_hack_state == 1)
{
if(layer_group)
{
// Set the window group level back to something less extreme
SetWindowGroupLevel(layer_group, kCGNormalWindowLevel);
}
window_hack_state = 2;
}
front_window = FrontWindow();
}
}
#endif
F64 elapsed = timer.getElapsedTimeF64();
F64 remaining = plugin->getSleepTime() - elapsed;
if(remaining <= 0.0f)
{
// We've already used our full allotment.
// LL_INFOS("slplugin") << "elapsed = " << elapsed * 1000.0f << " ms, remaining = " << remaining * 1000.0f << " ms, not sleeping" << LL_ENDL;
// Still need to service the network...
plugin->pump();
}
else
{
// LL_INFOS("slplugin") << "elapsed = " << elapsed * 1000.0f << " ms, remaining = " << remaining * 1000.0f << " ms, sleeping for " << remaining * 1000.0f << " ms" << LL_ENDL;
// timer.reset();
// This also services the network as needed.
plugin->sleep(remaining);
// LL_INFOS("slplugin") << "slept for "<< timer.getElapsedTimeF64() * 1000.0f << " ms" << LL_ENDL;
}
#if LL_WINDOWS
// More agressive checking of interfering exception handlers.
// Doesn't appear to be required so far - even for plugins
// that do crash with a single call to the intercept
// exception handler such as QuickTime.
//checkExceptionHandler();
#endif
#if LL_DARWIN
deleteAutoReleasePool();
#endif
}
delete plugin;
ll_cleanup_apr();
return 0;
}
void InitializeWindowAndInput(const char* windowTitle, int width, int height)
{
InitGlobalInput();
GenerateWindow(Input_WndProc, windowTitle, width, height);
ActivateWindow();
}
// Get search data
static int search_get_data(
FunctionHandle *handle,
SearchData *data)
{
NewConfigWindow new_win;
struct Window *window;
ObjectList *objlist;
Lister *lister;
short cancel=1;
// Fill out new window
if ((lister=function_lister_current(&handle->source_paths)))
{
new_win.parent=lister->window;
new_win.flags=0;
}
else
{
new_win.parent=GUI->screen_pointer;
new_win.flags=WINDOW_SCREEN_PARENT;
}
new_win.dims=&search_window;
new_win.title=GetString(&locale,MSG_ENTER_SEARCH_STRING);
new_win.locale=&locale;
new_win.port=0;
new_win.flags|=WINDOW_NO_CLOSE|WINDOW_VISITOR|WINDOW_AUTO_KEYS|WINDOW_REQ_FILL;
new_win.font=0;
// Open window
if (!(window=OpenConfigWindow(&new_win)) ||
!(objlist=AddObjectList(window,search_objects)))
{
CloseConfigWindow(window);
return 0;
}
// Initial settings
SetGadgetValue(objlist,GAD_SEARCH_TEXT,(ULONG)data->search_text);
SetGadgetValue(objlist,GAD_SEARCH_CASE,data->search_flags&SEARCH_NOCASE);
SetGadgetValue(objlist,GAD_SEARCH_WILD,data->search_flags&SEARCH_WILDCARD);
SetGadgetValue(objlist,GAD_SEARCH_ONLYWORD,data->search_flags&SEARCH_ONLYWORDS);
SetGadgetValue(objlist,GAD_SEARCH_RESULT,data->search_result);
// Activate text field
ActivateStrGad(GADGET(GetObject(objlist,GAD_SEARCH_TEXT)),window);
// Event loop
FOREVER
{
struct IntuiMessage *msg;
BOOL break_flag=0;
// Check for abort
if (function_check_abort(handle))
break;
// Activate?
if (handle->flags2&FUNCF_ACTIVATE_ME)
{
ActivateWindow(window);
WindowToFront(window);
handle->flags2&=~FUNCF_ACTIVATE_ME;
}
// Any Intuition messages?
while ((msg=GetWindowMsg(window->UserPort)))
{
struct IntuiMessage copy_msg;
// Copy message and reply
copy_msg=*msg;
ReplyWindowMsg(msg);
// Gadget?
if (copy_msg.Class==IDCMP_GADGETUP)
{
UWORD gadgetid;
// Get gadget id
gadgetid=((struct Gadget *)copy_msg.IAddress)->GadgetID;
// Look at gadget ID
switch (gadgetid)
{
// Okay
case GAD_SEARCH_TEXT:
case GAD_SEARCH_OKAY:
// Store flags
data->search_flags=0;
if (GetGadgetValue(objlist,GAD_SEARCH_CASE))
data->search_flags|=SEARCH_NOCASE;
if (GetGadgetValue(objlist,GAD_SEARCH_WILD))
data->search_flags|=SEARCH_WILDCARD;
if (GetGadgetValue(objlist,GAD_SEARCH_ONLYWORD))
data->search_flags|=SEARCH_ONLYWORDS;
data->search_result=GetGadgetValue(objlist,GAD_SEARCH_RESULT);
// Get search text
strcpy(data->search_text,(char *)GetGadgetValue(objlist,GAD_SEARCH_TEXT));
cancel=0;
// Cancel
case GAD_SEARCH_CANCEL:
break_flag=1;
break;
}
}
}
// Check break flag
if (break_flag) break;
// Wait for an event
Wait(1<<window->UserPort->mp_SigBit|1<<handle->ipc->command_port->mp_SigBit);
}
// Close window
CloseConfigWindow(window);
// Return
return !cancel;
}
void FiletypeEditor(void)
{
filetype_ed_data *data=0;
IPCData *ipc;
short success=0,pending_quit=0;
BOOL change_flag=0;
// Do startup
if (!(ipc=Local_IPC_ProcStartup((ULONG *)&data, (APTR)&_filetypeed_init)))
return;
// Create App stuff
if ((data->app_port=CreateMsgPort()))
{
data->app_window=AddAppWindowA(0,0,data->window,data->app_port,0);
}
// Get icon image
if (data->type->icon_path)
{
#ifdef USE_DRAWICONSTATE
{
char *path_copy;
data->icon_image=NULL;
if ((path_copy=AllocMemH(0,strlen(data->type->icon_path)+1)))
{
// icon_path is guaranteed to have a .info at the end
stccpy(path_copy,data->type->icon_path,strlen(data->type->icon_path)-4);
data->icon_image=GetCachedDiskObject(path_copy,0);
FreeMemH(path_copy);
}
}
#else
data->icon_image=OpenImage(data->type->icon_path,0);
#endif
// Show icon image
filetypeed_show_icon(data);
}
// Launch class editor immediately?
if (data->edit_flag) filetypeed_edit_definition(data);
// Message loop
FOREVER
{
IPCMessage *msg;
struct IntuiMessage *imsg;
short break_flag=0;
// Check drag
if (config_drag_check(&data->drag))
{
// End drag
filetypeed_end_drag(data,0);
}
// Task message?
while ((msg=(IPCMessage *)GetMsg(ipc->command_port)))
{
switch (msg->command)
{
// Close message?
case IPC_QUIT:
if (!pending_quit)
{
success=msg->flags;
break_flag=1;
}
break;
// Activate
case IPC_ACTIVATE:
if (data->window)
{
WindowToFront(data->window);
ActivateWindow(data->window);
}
break;
// Editor saying goodbye
case IPC_GOODBYE:
{
ULONG which;
// What's just gone?
which=IPC_GetGoodbye(msg);
// Class editor?
if (which==(ULONG)-1) data->class_editor=0;
// Icon menu editor?
else
if (which>15)
{
Att_Node *node;
// Go through icon list
for (node=(Att_Node *)data->icon_list->list.lh_Head;
node->node.ln_Succ;
node=(Att_Node *)node->node.ln_Succ)
{
// Match function
if (((func_node *)node->data)->func==(Cfg_Function *)which)
{
// Clear editor pointer
((func_node *)node->data)->editor=0;
// Check for invalid function
if (filetypeed_check_iconmenu(data,node,FALSE))
change_flag=1;
break;
}
}
}
// Normal filetype editor
else data->editor[which]=0;
}
break;
// Editor returning a function
case FUNCTIONEDIT_RETURN:
{
short ret;
if ((ret=filetypeed_receive_edit(
data,
(FunctionReturn *)msg->data)))
{
change_flag=1;
filetypeed_update_actions(data);
if (ret==2) filetypeed_update_iconmenu(data);
}
}
break;
// Class editor returning
case CLASSEDIT_RETURN:
filetypeed_receive_class(data,(Cfg_Filetype *)msg->data);
change_flag=1;
break;
// Get a copy of a button
case BUTTONEDIT_CLIP_BUTTON:
// Handle this button
if (filetypeed_get_button(data,(Cfg_Button *)msg->data,(Point *)msg->data_free))
change_flag=1;
break;
}
// Reply the message
IPC_Reply(msg);
}
// Intuimessage
if (data->window)
{
while ((imsg=GetWindowMsg(data->window->UserPort)))
{
struct IntuiMessage msg_copy;
struct Gadget *gadget;
struct TagItem *tags;
// Copy message
msg_copy=*imsg;
// Don't reply to IDCMPUPDATE messages just yet
if (imsg->Class!=IDCMP_IDCMPUPDATE)
{
ReplyWindowMsg(imsg);
imsg=0;
}
// Get gadget and tag pointers
gadget=(struct Gadget *)msg_copy.IAddress;
tags=(struct TagItem *)gadget;
// Look at message
switch (msg_copy.Class)
{
// Close window
case IDCMP_CLOSEWINDOW:
if (!pending_quit) break_flag=1;
break;
// Gadget
case IDCMP_GADGETUP:
switch (gadget->GadgetID)
{
// Use
case GAD_FILETYPEED_USE:
success=1;
// Cancel
case GAD_FILETYPEED_CANCEL:
if (!pending_quit) break_flag=1;
break;
// Select a function
case GAD_FILETYPEED_ACTION_LIST:
{
Att_Node *node;
// Get selected node
if (!(node=Att_FindNode(data->action_list,msg_copy.Code)))
break;
// Enable edit action button
DisableObject(data->objlist,GAD_FILETYPES_EDIT_ACTION,FALSE);
// Double-click?
if (!(DoubleClick(data->last_sec,data->last_mic,msg_copy.Seconds,msg_copy.Micros)) ||
node!=data->last_sel)
{
data->last_sec=msg_copy.Seconds;
data->last_mic=msg_copy.Micros;
data->last_sel=node;
data->last_icon=0;
break;
}
}
// Fall through
case GAD_FILETYPES_EDIT_ACTION:
// No current selection?
if (!data->last_sel) break;
// Is editor already up for this action?
if (data->editor[data->last_sel->data])
IPC_Command(data->editor[data->last_sel->data],IPC_ACTIVATE,0,0,0,0);
// Need to launch editor
else filetypeed_edit_action(data,data->last_sel->data,data->last_sel->node.ln_Name);
break;
// Delete action
case GAD_FILETYPES_DEL_ACTION:
// No current selection?
if (!data->last_sel) break;
// Is editor up for this action?
if (data->editor[data->last_sel->data])
IPC_Command(data->editor[data->last_sel->data],IPC_QUIT,0,0,0,0);
// Delete it
if (filetypeed_del_action(data,data->last_sel->data))
change_flag=1;
break;
// Edit filetype definition
case GAD_FILETYPEED_EDIT_CLASS:
// Is class editor already up for this action?
if (data->class_editor)
IPC_Command(data->class_editor,IPC_ACTIVATE,0,0,0,0);
// Need to launch editor
else filetypeed_edit_definition(data);
break;
// Select icon
case GAD_FILETYPEED_SELECT_ICON:
if (filetypeed_pick_icon(data))
change_flag=1;
break;
// Add to icon menu
case GAD_FILETYPES_ADD_ICON_MENU:
filetypeed_add_iconmenu(data);
break;
// Select an icon menu
case GAD_FILETYPES_ICON_MENU:
{
Att_Node *last=data->last_icon;
// Handle selection
if (!(filetypeed_sel_icon(data,msg_copy.Code))) break;
// Double-click?
if (data->last_icon!=last ||
!(DoubleClick(
data->last_sec,
data->last_mic,
msg_copy.Seconds,
msg_copy.Micros)))
{
data->last_sec=msg_copy.Seconds;
data->last_mic=msg_copy.Micros;
data->last_sel=0;
break;
}
}
// Fall through
case GAD_FILETYPES_EDIT_ICON_MENU:
// No current selection?
if (!data->last_icon) break;
// Edit it
filetypeed_edit_iconmenu(data,data->last_icon);
break;
// Delete from icon menu
case GAD_FILETYPES_DEL_ICON_MENU:
// No current selection?
if (!data->last_icon) break;
// Delete function
if (filetypeed_check_iconmenu(data,data->last_icon,TRUE))
change_flag=1;
break;
}
break;
// BOOPSI message
case IDCMP_IDCMPUPDATE:
{
short item;
// Icon list?
if (GetTagData(GA_ID,0,tags)!=GAD_FILETYPES_ICON_MENU) break;
// Get item
if ((item=GetTagData(DLV_DragNotify,-1,tags))!=-1)
{
// Handle selection
filetypeed_sel_icon(data,item);
// Start the drag
config_drag_start(&data->drag,data->icon_list,item,tags,TRUE);
}
}
break;
// Ticks
case IDCMP_INTUITICKS:
++data->drag.tick_count;
break;
// Mouse move
case IDCMP_MOUSEMOVE:
// Handle drag move
config_drag_move(&data->drag);
break;
// Mouse buttons
case IDCMP_MOUSEBUTTONS:
// Valid drag info?
if (data->drag.drag)
{
short ok=-1;
// Dropped ok?
if (msg_copy.Code==SELECTUP)
{
// Remember last position
data->drag.drag_x=data->window->WScreen->MouseX;
data->drag.drag_y=data->window->WScreen->MouseY;
ok=1;
}
// Aborted
else
if (msg_copy.Code==MENUDOWN) ok=0;
// End drag?
if (ok!=-1 && filetypeed_end_drag(data,ok)) change_flag=1;
}
break;
// Key press
case IDCMP_RAWKEY:
// Help?
if (msg_copy.Code==0x5f &&
!(msg_copy.Qualifier&VALID_QUALIFIERS))
{
// Set busy pointer
SetWindowBusy(data->window);
// Send help command
IPC_Command(data->func_startup.main_owner,IPC_HELP,(1<<31),"File Type Editor",0,REPLY_NO_PORT);
// Clear busy pointer
ClearWindowBusy(data->window);
}
break;
}
// Reply to outstanding messages
if (imsg) ReplyWindowMsg(imsg);
}
// Check break flag
if (break_flag || pending_quit)
{
// See if all the editors are gone
if (IsListEmpty(&data->proc_list.list))
break;
// Send quit?
if (break_flag)
{
IPC_ListQuit(&data->proc_list,0,success,FALSE);
SetWindowBusy(data->window);
}
pending_quit=1;
}
}
// AppMessage
if (data->app_window)
{
struct AppMessage *msg;
while ((msg=(struct AppMessage *)GetMsg(data->app_port)))
{
// Got an argument?
if (msg->am_NumArgs>0)
{
char name[256];
short len;
APTR image;
// Get full name
NameFromLock(msg->am_ArgList[0].wa_Lock,name,256);
if (msg->am_ArgList[0].wa_Name &&
*msg->am_ArgList[0].wa_Name)
AddPart(name,msg->am_ArgList[0].wa_Name,256);
// Add .info
if ((len=strlen(name))<6 ||
stricmp(name+len-5,".info")!=0) strcat(name,".info");
// Try to get image
#ifdef USE_DRAWICONSTATE
{
char *path_copy;
image=NULL;
if ((path_copy=AllocMemH(0,strlen(name)+1)))
{
// icon_path is guaranteed to have a .info at the end
stccpy(path_copy,name,strlen(name)-4);
image=GetCachedDiskObject(path_copy,0);
FreeMemH(path_copy);
}
}
#else
image=OpenImage(name,0);
#endif
if (image)
{
// Store path
FreeMemH(data->type->icon_path);
if ((data->type->icon_path=AllocMemH(0,strlen(name)+1)))
strcpy(data->type->icon_path,name);
// Free existing image
#ifdef USE_DRAWICONSTATE
FreeCachedDiskObject(data->icon_image);
#else
CloseImage(data->icon_image);
#endif
data->icon_image=image;
// Show new image
filetypeed_show_icon(data);
change_flag=1;
}
}
// Reply message
ReplyMsg((struct Message *)msg);
}
}
Wait(1<<ipc->command_port->mp_SigBit|
1<<data->drag.timer->port->mp_SigBit|
((data->window)?(1<<data->window->UserPort->mp_SigBit):0)|
((data->app_window)?(1<<data->app_port->mp_SigBit):0));
}
// End any drag in progress
filetypeed_end_drag(data,0);
// Need to send button back?
if (success==1 && change_flag)
{
if (IPC_Command(
data->owner_ipc,
FILETYPEEDIT_RETURN,
(ULONG)data->type,
data->node,
0,
REPLY_NO_PORT))
{
data->node=0;
}
}
// Free edit filetype
FreeFiletype(data->type);
// Remove AppWindow
RemoveAppWindow(data->app_window);
// Close window
CloseConfigWindow(data->window);
// Close app port
if (data->app_port)
{
struct Message *msg;
while ((msg=GetMsg(data->app_port)))
ReplyMsg(msg);
DeleteMsgPort(data->app_port);
}
// Say goodbye
IPC_Goodbye(ipc,data->owner_ipc,(success==-1)?0:(ULONG)data->node);
// Free icon image
#ifdef USE_DRAWICONSTATE
FreeCachedDiskObject(data->icon_image);
#else
CloseImage(data->icon_image);
#endif
// Close timer
FreeTimer(data->drag.timer);
// Free data
IPC_Free(ipc);
Att_RemList(data->action_list,0);
Att_RemList(data->icon_list,REMLIST_FREEDATA);
FreeVec(data);
}
short LIBFUNC L_DoSimpleRequest(
REG(a0, struct Window *parent),
REG(a1, struct DOpusSimpleRequest *simple),
REG(a6, struct Library *libbase))
{
APTR memory;
simplereq_data *data;
UWORD gadgetid=0;
#ifdef __amigaos4__
libbase = (struct Library *)dopuslibbase_global;
#endif
// Allocate memory handle
if (!(memory=L_NewMemHandle(0,0,MEMF_CLEAR)))
return 1;
// Allocate data
if (!(data=(simplereq_data *)L_AllocMemH(memory,sizeof(simplereq_data))))
{
L_FreeMemHandle(memory);
return 1;
}
// Initialise
data->simple=simple;
data->parent=parent;
data->string_buffer=simple->string_buffer;
data->gadgets=simple->gadgets;
data->libbase=(struct MyLibrary *)libbase;
data->signal=-1;
data->memory=memory;
// Center window; over mouse?
if (simple->flags&SRF_MOUSE_POS)
{
data->req_dims.char_dim.Left=POS_MOUSE_CENTER;
data->req_dims.char_dim.Top=POS_MOUSE_CENTER;
}
// Over parent
else
{
data->req_dims.char_dim.Left=POS_CENTER;
data->req_dims.char_dim.Top=POS_CENTER;
}
// Construct requester
if (!(simple_build(data)))
{
// Failed
L_FreeMemHandle(memory);
return 1;
}
// IPC port supplied?
if (simple->flags&SRF_IPC && simple->ipc)
{
data->ipc=simple->ipc;
data->waitbits=1<<data->ipc->command_port->mp_SigBit;
}
// Signal supplied?
else
if (simple->flags&SRF_SIGNAL)
{
data->signal=(short)simple->ipc;
data->waitbits=1<<data->signal;
}
// Otherwise
else
{
data->waitbits=IPCSIG_QUIT;
SetSignal(0,IPCSIG_QUIT);
}
// Open requester
if (_simplereq_open(data,parent))
{
// Wait on requester
FOREVER
{
struct IntuiMessage *msg;
IPCMessage *imsg;
short break_flag=0;
ULONG waitres;
// IPC message?
if (data->ipc)
{
while ((imsg=(IPCMessage *)GetMsg(data->ipc->command_port)))
{
if (imsg->command==IPC_HIDE)
_simplereq_close(data);
else
if (imsg->command==IPC_SHOW)
{
if (!(_simplereq_open(data,imsg->data)))
break_flag=1;
}
else
if (imsg->command==IPC_ACTIVATE)
{
if (data->window)
{
WindowToFront(data->window);
ActivateWindow(data->window);
}
}
else
if (imsg->command==IPC_QUIT || imsg->command==IPC_ABORT)
{
break_flag=1;
gadgetid=(UWORD)-1;
}
L_IPC_Reply(imsg);
}
}
// Intuition message?
if (data->window)
{
while ((msg=L_GetWindowMsg(data->window->UserPort, (APTR)libbase)))
{
struct IntuiMessage copy_msg;
// Copy message and reply
copy_msg=*msg;
L_ReplyWindowMsg(msg);
// Check message type
if (copy_msg.Class==IDCMP_GADGETUP)
{
// Get gadget ID
gadgetid=((struct Gadget *)copy_msg.IAddress)->GadgetID;
// Checkbox?
if (gadgetid==GAD_CHECK_ID)
{
// Store value
if (simple->check_ptr) *simple->check_ptr=copy_msg.Code;
}
// Tab on a string gadget?
else
if (gadgetid==GAD_STRING2_ID ||
(gadgetid==GAD_STRING_ID &&
(copy_msg.Code==0x9 ||
copy_msg.Code==0x45 ||
copy_msg.Qualifier&(IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT))))
continue;
// Popup gadget?
else
if (gadgetid==GAD_POPUP_ID)
{
char buf[400],file[40],*ptr;
struct TagItem tags[4];
// Get initial path and file
strcpy(buf,(char *)L_GetGadgetValue(data->objlist,GAD_STRING_ID,data->libbase));
if ((ptr=FilePart(buf)))
{
stccpy(file,ptr,40);
*ptr=0;
}
else file[0]=0;
// Initialise tags
tags[0].ti_Tag=ASLFR_Window;
tags[0].ti_Data=(ULONG)data->window;
tags[1].ti_Tag=ASLFR_InitialFile;
tags[1].ti_Data=(ULONG)file;
tags[2].ti_Tag=ASLFR_InitialDrawer;
tags[2].ti_Data=(ULONG)buf;
tags[3].ti_Tag=TAG_END;
// Show requester
if (simple->filereq &&
AslRequest(simple->filereq,tags))
{
// Build new path
strcpy(buf,((struct FileRequester *)simple->filereq)->fr_Drawer);
AddPart(buf,((struct FileRequester *)simple->filereq)->fr_File,400);
// Show in string gadget
L_SetGadgetValue(data->objlist,GAD_STRING_ID,(long)buf);
L_ActivateStrGad(GADGET(L_GetObject(data->objlist,GAD_STRING_ID)),data->window);
}
continue;
}
// Set break flag
else break_flag=1;
}
// Key press
else
if (copy_msg.Class==IDCMP_VANILLAKEY)
{
// Y = yes
if (copy_msg.Code=='y' || copy_msg.Code=='Y')
{
gadgetid=1;
break_flag=1;
}
// N = no
else
if (copy_msg.Code=='n' || copy_msg.Code=='N')
{
gadgetid=0;
break_flag=1;
}
}
}
}
// Check break flag
if (break_flag) break;
// Wait for a message
waitres=Wait(data->waitbits|
((data->window)?(1<<data->window->UserPort->mp_SigBit):0));
// Quit?
if (waitres&IPCSIG_QUIT)
{
gadgetid=0;
break;
}
// Signal?
else
if (data->signal!=-1 && (waitres&(1<<data->signal)))
{
gadgetid=(UWORD)-5;
break;
}
}
}
// Close requester
_simplereq_close(data);
// Free memory
L_FreeMemHandle(memory);
// Return gadget code
return gadgetid;
}
/**************************************************************************
* Update functions
*/
void SystemUpdate(void)
{
if (isNotepadCreated == FALSE)
return;
OutputDebugString(_T("SystemUpdate\n"));
UINT oldSC = currentSC;
UINT newDocCnt = 0;
TCHAR pszNewPath[MAX_PATH];
/* update open files */
UpdateCurrentHScintilla();
::SendMessage(nppData._nppHandle, NPPM_GETFULLCURRENTPATH, 0, (LPARAM)pszNewPath);
INT newOpenDoc1 = (INT)::SendMessage(nppData._nppHandle, NPPM_GETCURRENTDOCINDEX, 0, MAIN_VIEW);
INT newOpenDoc2 = (INT)::SendMessage(nppData._nppHandle, NPPM_GETCURRENTDOCINDEX, 0, SUB_VIEW);
if ((newOpenDoc1 != openDoc1) || (newOpenDoc2 != openDoc2) ||
(_tcscmp(pszNewPath, currentPath) != 0) || (oldSC != currentSC))
{
/* set new file */
_tcscpy(currentPath, pszNewPath);
openDoc1 = newOpenDoc1;
openDoc2 = newOpenDoc2;
INT i = 0;
INT docCnt1;
INT docCnt2;
LPCTSTR *fileNames1;
LPCTSTR *fileNames2;
BOOL isAllocOk = TRUE;
/* update doc information */
docCnt1 = (INT)::SendMessage(nppData._nppHandle, NPPM_GETNBOPENFILES, 0, (LPARAM)PRIMARY_VIEW);
docCnt2 = (INT)::SendMessage(nppData._nppHandle, NPPM_GETNBOPENFILES, 0, (LPARAM)SECOND_VIEW);
fileNames1 = (LPCTSTR*)new LPTSTR[docCnt1];
fileNames2 = (LPCTSTR*)new LPTSTR[docCnt2];
if ((fileNames1 != NULL) && (fileNames2 != NULL))
{
for (i = 0; (i < docCnt1) && (isAllocOk == TRUE); i++) {
fileNames1[i] = (LPTSTR)new TCHAR[MAX_PATH];
if (fileNames1[i] == NULL)
isAllocOk = FALSE;
}
for (i = 0; (i < docCnt2) && (isAllocOk == TRUE); i++) {
fileNames2[i] = (LPTSTR)new TCHAR[MAX_PATH];
if (fileNames2[i] == NULL)
isAllocOk = FALSE;
}
if (isAllocOk == TRUE)
{
::SendMessage(nppData._nppHandle, NPPM_GETOPENFILENAMESPRIMARY, (WPARAM)fileNames1, (LPARAM)docCnt1);
hexEdit1.UpdateDocs(fileNames1, docCnt1, openDoc1);
::SendMessage(nppData._nppHandle, NPPM_GETOPENFILENAMESSECOND, (WPARAM)fileNames2, (LPARAM)docCnt2);
hexEdit2.UpdateDocs(fileNames2, docCnt2, openDoc2);
/* update edit */
if (currentSC == MAIN_VIEW)
pCurHexEdit = &hexEdit1;
else
pCurHexEdit = &hexEdit2;
ActivateWindow();
setMenu();
}
if (fileNames1 != NULL)
{
for (i = 0; i < docCnt1; i++)
if (fileNames1[i] != NULL)
delete [] fileNames1[i];
delete [] fileNames1;
}
if (fileNames2 != NULL)
{
for (i = 0; i < docCnt2; i++)
if (fileNames2[i] != NULL)
delete [] fileNames2[i];
delete [] fileNames2;
}
}
}
DialogUpdate();
}
BOOL ami_search_event(void)
{
/* return TRUE if window destroyed */
ULONG result;
uint16 code;
search_flags_t flags;
while((result = RA_HandleInput(fwin->objects[OID_MAIN],&code)) != WMHI_LASTMSG)
{
switch(result & WMHI_CLASSMASK) // class
{
case WMHI_GADGETUP:
switch(result & WMHI_GADGETMASK)
{
case GID_SEARCHSTRING:
browser_window_search_clear(fwin->gwin->bw);
RefreshSetGadgetAttrs((struct Gadget *)fwin->objects[GID_PREV],
fwin->win, NULL,
GA_Disabled, FALSE,
TAG_DONE);
RefreshSetGadgetAttrs((struct Gadget *)fwin->objects[GID_NEXT],
fwin->win, NULL,
GA_Disabled, FALSE,
TAG_DONE);
/* fall through */
case GID_NEXT:
search_insert = true;
flags = SEARCH_FLAG_FORWARDS |
ami_search_flags();
browser_window_search(
fwin->gwin->bw,
NULL,
flags, ami_search_string());
ActivateWindow(fwin->gwin->shared->win);
break;
case GID_PREV:
search_insert = true;
flags = ~SEARCH_FLAG_FORWARDS &
ami_search_flags();
browser_window_search(
fwin->gwin->bw,
NULL,
flags, ami_search_string());
ActivateWindow(fwin->gwin->shared->win);
break;
}
break;
case WMHI_CLOSEWINDOW:
ami_search_close();
return TRUE;
break;
}
}
return FALSE;
}
void FunctionEditor(void)
{
struct IntuiMessage *gmsg,msg;
int break_flag=0;
UWORD gadgetid=0;
ULONG waitbits;
FuncEdData *data;
IPCData *ipc;
NewConfigWindow newwin;
FunctionStartup *startup=0;
IPCMessage *submsg;
int success=0;
BOOL open_window=1;
BPTR lock;
ConfigWindow windims;
// Do startup
if (!(ipc=Local_IPC_ProcStartup((ULONG *)&startup, (APTR)&funced_init)))
{
funced_cleanup(startup->data);
return;
}
// Get data pointer
data=startup->data;
// Lock RAM: and CD to it
if ((lock=Lock("ram:",ACCESS_READ)))
lock=CurrentDir(lock);
// Copy dimensions
if (startup->flags&FUNCEDF_CENTER)
windims=_function_editor_window_center;
else
if (startup->flags&FUNCEDF_LABEL)
windims=_function_editor_label_window;
else
windims=_function_editor_window;
// Fill in new window
newwin.parent=startup->window;
newwin.dims=&windims;
newwin.title=(startup->title[0])?startup->title:(char *)GetString(startup->locale,MSG_FUNCED_TITLE);
newwin.locale=startup->locale;
newwin.port=0;
newwin.flags=WINDOW_VISITOR|WINDOW_AUTO_KEYS|WINDOW_REQ_FILL;//|WINDOW_SIZE_BOTTOM;
newwin.font=0;
// Build flag list
funced_build_flaglist(data);
waitbits=1<<ipc->command_port->mp_SigBit|1<<data->drag.timer->port->mp_SigBit;
// Event loop
FOREVER
{
// Check drag
if (config_drag_check(&data->drag))
{
// End drag
functioned_end_drag(data,0);
}
// Task message?
while ((submsg=(IPCMessage *)GetMsg(ipc->command_port)))
{
// Close message?
if (submsg->command==IPC_QUIT)
{
// Keep changes?
success=submsg->flags;
// Set break flag
break_flag=1;
}
// Activate
else
if (submsg->command==IPC_ACTIVATE && data->window)
{
WindowToFront(data->window);
ActivateWindow(data->window);
}
// Hide
else
if (submsg->command==IPC_HIDE && data->window)
{
// Store changes in function
funced_store_edits(data);
// End any drag in progress
functioned_end_drag(data,0);
// Remove AppWindow
RemoveAppWindow(data->appwindow);
data->appwindow=0;
// Close window
CloseConfigWindow(data->window);
// Zero stuff
data->window=0;
data->objlist=0;
waitbits=1<<ipc->command_port->mp_SigBit;
}
// Show
else
if (submsg->command==IPC_SHOW && !data->window)
{
// Set flag to open window
open_window=1;
newwin.parent=(struct Window *)submsg->data;
}
// Passed-along app message
else
if (submsg->command==CFG_APPMESSAGE_PASS)
{
funced_appmsg(data,submsg->data);
ReplyMsg((struct Message *)submsg->data);
}
// Update our identity
else
if (submsg->command==CFG_NEW_ID)
{
data->function->function.func_type=submsg->flags;
startup->object_flags=(ULONG)submsg->data;
}
// Copy a function
else
if (submsg->command==FUNCTIONEDIT_COPY_LINE)
{
FunctionEntry *entry,*next;
// Copy function
functioned_copy_line(
data,
(FunctionEntry *)submsg->data,
0,
(Point *)submsg->data_free);
// Free function
entry=(FunctionEntry *)submsg->data;
while (entry)
{
// Get next
next=(FunctionEntry *)entry->node;
// Free entry
FreeVec(entry);
entry=next;
}
}
// Clip button
else
if (submsg->command==BUTTONEDIT_CLIP_BUTTON)
{
Cfg_ButtonFunction *func;
// Show busy pointer
SetWindowBusy(data->window);
// Stop editing
funced_end_edit(data,data->edit_node,0,0);
data->edit_node=0;
// Get first function
if ((func=(Cfg_ButtonFunction *)
FindFunctionType(
(struct List *)&((Cfg_Button *)submsg->data)->function_list,
FTYPE_LEFT_BUTTON)))
{
FunctionEntry dummy;
Cfg_Instruction *ins;
// Go through instructions
for (ins=(Cfg_Instruction *)func->instructions.mlh_Head;
ins->node.mln_Succ;
ins=(Cfg_Instruction *)ins->node.mln_Succ)
{
// Fill out dummy entry
dummy.type=ins->type;
if (ins->string) strcpy(dummy.buffer,ins->string);
else dummy.buffer[0]=0;
// Copy function line
data->edit_node=funced_new_entry(data,0,&dummy);
}
// Start editing last line
funced_start_edit(data);
// Get flags
data->function->function.flags=func->function.flags;
data->function->function.code=func->function.code;
data->function->function.qual=func->function.qual;
data->function->function.qual_mask=func->function.qual_mask;
data->function->function.qual_same=func->function.qual_same;
// Update flag list
funced_update_flaglist(data);
// Update key
funced_show_key(data);
}
// Free button
FreeButton((Cfg_Button *)submsg->data);
// Clear busy pointer
ClearWindowBusy(data->window);
}
// Reply the message
IPC_Reply(submsg);
}
// Open window?
if (open_window)
{
// Open window
if (!(data->window=OpenConfigWindow(&newwin)) ||
!(data->p_objlist=AddObjectList(
data->window,
(startup->flags&FUNCEDF_IMAGE)?_function_editor_image_objects:
((startup->flags&FUNCEDF_LABEL)?_function_editor_label_objects:
_function_editor_normal_objects))) ||
!(data->objlist=AddObjectList(data->window,_function_editor_objects)))
break;
// Add use or save button
AddObjectList(data->window,(startup->flags&FUNCEDF_SAVE)?_function_editor_objects_save:_function_editor_objects_use);
// Store window for drag
data->drag.window=data->window;
// Set window ID
SetWindowID(data->window,0,WINDOW_FUNCTION_EDITOR,(struct MsgPort *)ipc);
// Add menus
AddWindowMenus(data->window,_funced_menus);
// Make this an AppWindow
data->appwindow=AddAppWindowA(0,0,data->window,data->appport,0);
// Get waitbits
waitbits|=1<<data->window->UserPort->mp_SigBit;
if (data->appwindow) waitbits|=1<<data->appport->mp_SigBit;
// Disable key?
if (startup->flags&FUNCEDF_NO_KEY)
{
DisableObject(data->objlist,GAD_FUNCED_KEY,TRUE);
}
// Initialise gadgets with function data.
funced_init_gads(data);
open_window=0;
}
// Intuimessage
if (data->window)
{
while ((gmsg=GetWindowMsg(data->window->UserPort)))
{
Att_Node *node;
// Copy message and reply (unless IDCMPUPDATE)
msg=*gmsg;
if (gmsg->Class!=IDCMP_IDCMPUPDATE)
{
ReplyWindowMsg(gmsg);
gmsg=0;
}
// Get GadgetID
if (msg.Class==IDCMP_GADGETDOWN ||
msg.Class==IDCMP_GADGETUP)
gadgetid=((struct Gadget *)msg.IAddress)->GadgetID;
// Look at message
switch (msg.Class)
{
// Key press
case IDCMP_VANILLAKEY:
// If editing something, activate string gadget
if (data->edit_node)
ActivateStrGad(GADGET(GetObject(data->objlist,GAD_FUNCED_EDIT)),data->window);
break;
// Close window
case IDCMP_CLOSEWINDOW:
// Set break flag
break_flag=1;
break;
// Mouse move
case IDCMP_MOUSEMOVE:
// Handle drag move
config_drag_move(&data->drag);
break;
// Inactive window does menu down
case IDCMP_INACTIVEWINDOW:
msg.Code=MENUDOWN;
// Mouse buttons
case IDCMP_MOUSEBUTTONS:
// Valid drag info?
if (data->drag.drag)
{
short ok=-1;
// Dropped ok?
if (msg.Code==SELECTUP)
{
// Is shift down?
if (msg.Qualifier&(IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT))
data->drag_shift=1;
else data->drag_shift=0;
// Remember last position
data->drag.drag_x=data->window->WScreen->MouseX;
data->drag.drag_y=data->window->WScreen->MouseY;
ok=1;
}
// Aborted
else
if (msg.Code==MENUDOWN)
{
// Set abort
ok=0;
}
// End drag?
if (ok!=-1) functioned_end_drag(data,ok);
}
break;
// Menu
case IDCMP_MENUPICK:
{
struct MenuItem *item;
// Get item
if (!(item=ItemAddress(data->window->MenuStrip,msg.Code)))
break;
// Treat as gadget
gadgetid=MENUID(item);
}
// Gadget
case IDCMP_GADGETUP:
case IDCMP_GADGETDOWN:
// Look at gadget ID
switch (gadgetid)
{
// Hotkey
case GAD_FUNCED_KEY:
{
IX ix;
char *ptr;
// Get key, see if it's invalid
if ((ptr=(char *)GetGadgetValue(data->objlist,GAD_FUNCED_KEY)) && *ptr)
{
// Try to parse
if (ParseIX(ptr,&ix))
{
// Flash screen
DisplayBeep(data->window->WScreen);
// Activate key field again
ActivateStrGad(GADGET(GetObject(data->objlist,GAD_FUNCED_KEY)),data->window);
}
else
{
data->function->function.code=ix.ix_Code;
data->function->function.qual=QualValid(ix.ix_Qualifier);
data->function->function.qual_mask=ix.ix_QualMask;
data->function->function.qual_same=ix.ix_QualSame;
}
}
}
break;
// Flag selected
case GAD_FUNCED_FLAGS:
// Get selected node
node=Att_FindNode(data->flag_list,msg.Code);
// Set flag
data->function->function.flags^=node->data;
// Check change
funced_check_flag(&data->function->function.flags,node->data);
// Update flag list
funced_update_flaglist(data);
break;
// Edit a line
case GAD_FUNCED_LISTER:
// Get selected node
node=Att_FindNode(data->func_display_list,msg.Code);
// Is this the node we're already editing?
if (node==data->edit_node) break;
// If we're editing another one, store its contents
if (data->edit_node)
funced_end_edit(data,data->edit_node,0,0);
// Start editing this entry
data->edit_node=node;
funced_start_edit(data);
break;
// Return pressed in edit line
case GAD_FUNCED_EDIT:
// See if we were editing something
if (data->edit_node)
{
// Stop editing
funced_end_edit(data,data->edit_node,END_DISABLE,msg.Qualifier);
data->edit_node=0;
}
break;
// New entry
case GAD_FUNCED_NEW_ENTRY:
case GAD_FUNCED_INSERT_ENTRY:
// Create new entry
functioned_copy_line(data,0,gadgetid,0);
break;
// Delete entry
case GAD_FUNCED_DELETE_ENTRY:
// Check we were editing something
if (!data->edit_node) break;
// Stop editing (signal delete)
funced_end_edit(data,data->edit_node,END_DISABLE|END_DELETE,0);
data->edit_node=0;
break;
// Function type
case GAD_FUNCED_FUNCTION_TYPE:
// Check we were editing something
if (!data->edit_node) break;
// Store type
((FunctionEntry *)data->edit_node->data)->type=msg.Code;
// Disable popup button if no functions
DisableObject(
data->objlist,
GAD_FUNCED_EDIT_GLASS,
(msg.Code==INST_COMMAND && !data->startup->func_list));
break;
// Glass gadget
case GAD_FUNCED_EDIT_GLASS:
// Check we were editing something
if (data->edit_node)
{
char buffer[256];
// Put up requester
if (!(funced_command_req(
data,
buffer,
((FunctionEntry *)data->edit_node->data)->type)))
break;
// Insert string in edit line
funced_edit_insertstring(
data->objlist,
GAD_FUNCED_EDIT,
buffer,
DOpusBase,(struct Library *)IntuitionBase);
}
break;
// Argument list
case GAD_FUNCED_EDIT_ARGUMENT:
// Check we were editing something
if (data->edit_node)
{
char buffer[80];
// Put up requester
if (!(funced_command_req(
data,
buffer,
-1))) break;
// Insert string in edit line
funced_edit_insertstring(
data->objlist,
GAD_FUNCED_EDIT,
buffer,
DOpusBase,(struct Library *)IntuitionBase);
}
break;
// Export
case MENU_FUNCED_EXPORT_ASCII:
case MENU_FUNCED_EXPORT_CMD:
// Got file requester?
if (WINREQUESTER(data->window))
{
struct TagItem tags[6];
struct FileRequester *req=WINREQUESTER(data->window);
// Show busy pointer
SetWindowBusy(data->window);
// File requester tags
tags[0].ti_Tag=ASLFR_Window;
tags[0].ti_Data=(ULONG)data->window;
tags[1].ti_Tag=ASLFR_TitleText;
tags[1].ti_Data=(ULONG)GetString(startup->locale,MSG_FUNCED_SELECT_FILE);
tags[2].ti_Tag=ASLFR_Flags1;
tags[2].ti_Data=FRF_DOSAVEMODE|FRF_PRIVATEIDCMP;
tags[3].ti_Tag=ASLFR_Flags2;
tags[3].ti_Data=FRF_REJECTICONS;
tags[4].ti_Tag=(gadgetid==MENU_FUNCED_EXPORT_CMD)?ASLFR_InitialDrawer:TAG_DONE;
tags[4].ti_Data=(ULONG)"DOpus5:Commands";
tags[5].ti_Tag=TAG_DONE;
// Show filerequester
if (AslRequest(req,tags))
{
// Build filename
strcpy(data->buffer,req->fr_Drawer);
AddPart(data->buffer,req->fr_File,256);
// Store changes in function
funced_store_edits(data);
// Do export
if (gadgetid==MENU_FUNCED_EXPORT_CMD)
function_export_cmd(data->buffer,0,data->function);
else
L_FunctionExportASCII(data->buffer,0,data->function,startup->a4);
}
// Remove busy pointer
ClearWindowBusy(data->window);
}
break;
// Cut/Copy
case MENU_FUNCED_CUT:
case MENU_FUNCED_COPY:
{
APTR iff;
// Set busy pointer
SetWindowBusy(data->window);
// Open clipboard
if ((iff=IFFOpen((char *)0,IFF_CLIP_WRITE,ID_OPUS)))
{
// Stop editing
funced_end_edit(data,data->edit_node,END_DISABLE,0);
data->edit_node=0;
// Store changes in function
funced_store_edits(data);
// Save function
SaveFunction(iff,data->function);
// Close clipboard
IFFClose(iff);
}
// Just copy, not cut?
if (gadgetid==MENU_FUNCED_COPY)
{
// Clear busy pointer
ClearWindowBusy(data->window);
break;
}
// Fall through, paste null function
}
// Paste
case MENU_FUNCED_PASTE:
{
Cfg_Function *func=0;
// Set busy pointer
SetWindowBusy(data->window);
// End any edit
funced_end_edit(data,data->edit_node,END_DISABLE,0);
data->edit_node=0;
// Paste?
if (gadgetid==MENU_FUNCED_PASTE)
{
APTR iff;
// Open clipboard
if ((iff=IFFOpen((char *)0,IFF_CLIP_READ,ID_OPUS)))
{
// Find function
if (IFFNextChunk(iff,ID_FUNC))
{
// Read function
func=ReadFunction(iff,0,0,0);
}
// Close clipboard
IFFClose(iff);
}
// No valid function?
if (!func)
{
// Flash error
DisplayBeep(data->window->WScreen);
ClearWindowBusy(data->window);
break;
}
}
// Detach existing list
SetGadgetChoices(data->objlist,GAD_FUNCED_FLAGS,(APTR)~0);
// Clear function list
Att_RemList(data->function_list,REMLIST_SAVELIST|REMLIST_FREEDATA);
// Free existing instructions
FreeInstructionList(data->function);
// Rebuild display list
funced_build_display(data);
// Clear flags
data->function->function.flags=0;
funced_update_flaglist(data);
// Clear key
data->function->function.code=0xffff;
SetGadgetValue(data->objlist,GAD_FUNCED_KEY,0);
// Clear label
if (startup->flags&FUNCEDF_LABEL)
{
data->label[0]=0;
SetGadgetValue(data->p_objlist,GAD_FUNCED_LABEL,0);
}
// Paste function in?
if (func)
{
short type;
// Save type
type=data->function->function.func_type;
// Copy function in
CopyFunction(func,0,data->function);
data->function->function.func_type=type;
// Free copied function
FreeFunction(func);
// Initialise gadgets
funced_init_gads(data);
}
// Clear busy pointer
ClearWindowBusy(data->window);
}
break;
// Use
case GAD_FUNCED_USE:
success=1;
// Cancel
case GAD_FUNCED_CANCEL:
break_flag=1;
break;
}
break;
// Key press
case IDCMP_RAWKEY:
// Help?
if (msg.Code==0x5f &&
!(msg.Qualifier&VALID_QUALIFIERS))
{
// Set busy pointer
SetWindowBusy(data->window);
// Send help command
IPC_Command(startup->main_owner,IPC_HELP,(1<<31),"Function Editor",0,REPLY_NO_PORT);
// Clear busy pointer
ClearWindowBusy(data->window);
}
break;
// BOOPSI message
case IDCMP_IDCMPUPDATE:
{
struct TagItem *tags=(struct TagItem *)msg.IAddress;
short item;
// Check ID
if (GetTagData(GA_ID,0,tags)!=GAD_FUNCED_LISTER)
break;
// Get item
if ((item=GetTagData(DLV_DragNotify,-1,tags))!=-1)
{
// Start the drag
config_drag_start(&data->drag,data->func_display_list,item,tags,TRUE);
}
}
break;
// Ticks
case IDCMP_INTUITICKS:
++data->drag.tick_count;
break;
}
// Reply to any outstanding message
if (gmsg) ReplyWindowMsg(gmsg);
}
}
// AppMessage
if (data->appwindow)
{
struct AppMessage *msg;
while ((msg=(struct AppMessage *)GetMsg(data->appport)))
{
// Make sure window is active
ActivateWindow(data->window);
// Handle message
funced_appmsg(data,msg);
ReplyMsg((struct Message *)msg);
}
}
// Check break flag
if (break_flag) break;
// Wait for message
Wait(waitbits);
}
// Restore CD
if (lock) UnLock(CurrentDir(lock));
// Edit successful?
if (success)
{
FunctionReturn ret;
// Store changes in function
funced_store_edits(data);
// Fill out return data
ret.object=startup->object;
ret.object_flags=startup->object_flags;
ret.function=data->function;
// Send new function back
IPC_Command(startup->owner_ipc,FUNCTIONEDIT_RETURN,0,&ret,0,REPLY_NO_PORT);
}
// End any drag in progress
functioned_end_drag(data,0);
// Free edit function
FreeFunction(data->function);
// Close window
RemoveAppWindow(data->appwindow);
CloseConfigWindow(data->window);
// Close application port
if (data->appport)
{
struct Message *msg;
while ((msg=GetMsg(data->appport)))
ReplyMsg(msg);
DeleteMsgPort(data->appport);
}
// Say goodbye
IPC_Goodbye(ipc,startup->owner_ipc,startup->object_flags);
// Delete IPC data
Forbid();
IPC_Free(ipc);
// Free data
funced_cleanup(data);
FreeVec(startup);
}
/**
* Change the displayed search status.
*
* \param gwin gui window to open search for.
*/
void ami_search_open(struct gui_window *gwin)
{
search_insert = true;
if(fwin)
{
browser_window_search_clear(fwin->gwin->bw);
fwin->gwin->shared->searchwin = NULL;
fwin->gwin = gwin;
gwin->shared->searchwin = fwin;
WindowToFront(fwin->win);
ActivateWindow(fwin->win);
return;
}
fwin = ami_misc_allocvec_clear(sizeof(struct find_window), 0);
fwin->objects[OID_MAIN] = WindowObj,
WA_ScreenTitle, ami_gui_get_screen_title(),
WA_Title,messages_get("FindTextNS"),
WA_Activate, TRUE,
WA_DepthGadget, TRUE,
WA_DragBar, TRUE,
WA_CloseGadget, TRUE,
WA_SizeGadget, TRUE,
WA_PubScreen,scrn,
WINDOW_SharedPort,sport,
WINDOW_UserData,fwin,
WINDOW_IconifyGadget, FALSE,
WINDOW_LockHeight,TRUE,
WINDOW_Position, WPOS_CENTERSCREEN,
WINDOW_ParentGroup, fwin->objects[GID_MAIN] = LayoutVObj,
LAYOUT_AddChild, fwin->objects[GID_SEARCHSTRING] = StringObj,
GA_ID,GID_SEARCHSTRING,
GA_TabCycle,TRUE,
GA_RelVerify,TRUE,
StringEnd,
CHILD_WeightedHeight,0,
LAYOUT_AddChild, fwin->objects[GID_CASE] = CheckBoxObj,
GA_ID,GID_CASE,
GA_Text,messages_get("CaseSens"),
GA_Selected,FALSE,
GA_TabCycle,TRUE,
GA_RelVerify,TRUE,
CheckBoxEnd,
LAYOUT_AddChild, fwin->objects[GID_SHOWALL] = CheckBoxObj,
GA_ID,GID_SHOWALL,
GA_Text,messages_get("ShowAll"),
GA_Selected,FALSE,
GA_TabCycle,TRUE,
GA_RelVerify,TRUE,
CheckBoxEnd,
LAYOUT_AddChild, LayoutHObj,
LAYOUT_AddChild, fwin->objects[GID_PREV] = ButtonObj,
GA_ID,GID_PREV,
GA_RelVerify,TRUE,
GA_Text,messages_get("Prev"),
GA_TabCycle,TRUE,
GA_Disabled,TRUE,
ButtonEnd,
CHILD_WeightedHeight,0,
LAYOUT_AddChild, fwin->objects[GID_NEXT] = ButtonObj,
GA_ID,GID_NEXT,
GA_RelVerify,TRUE,
GA_Text,messages_get("Next"),
GA_TabCycle,TRUE,
GA_Disabled,TRUE,
ButtonEnd,
LayoutEnd,
CHILD_WeightedHeight,0,
EndGroup,
EndWindow;
fwin->win = (struct Window *)RA_OpenWindow(fwin->objects[OID_MAIN]);
fwin->gwin = gwin;
fwin->node = AddObject(window_list,AMINS_FINDWINDOW);
fwin->node->objstruct = fwin;
gwin->shared->searchwin = fwin;
ActivateLayoutGadget((struct Gadget *)fwin->objects[GID_MAIN], fwin->win,
NULL, (ULONG)fwin->objects[GID_SEARCHSTRING]);
}
int LIBFUNC L_Module_Entry(
REG(a0, struct List *files),
REG(a1, struct Screen *screen),
REG(a2, IPCData *ipc),
REG(a3, IPCData *main_ipc),
REG(d0, ULONG mod_id),
REG(d1, ULONG mod_data))
{
config_path_data *data;
short success=1;
// Allocate data
if (!(data=AllocVec(sizeof(config_path_data),MEMF_CLEAR)) ||
!(data->path_list=Att_NewList(0)))
{
FreeVec(data);
return 0;
}
// Store data pointers
data->paths=files;
data->ipc=ipc;
data->main_ipc=main_ipc;
data->memory=(APTR)mod_id;
data->def_format=(ListFormat *)mod_data;
// AppPort
data->appport=CreateMsgPort();
// Open commodities library
/*data->cxbase=OpenLibrary("commodities.library",0);
#ifdef __amigaos4__
ICommodities=(struct CommoditiesIFace *)GetInterface(data->cxbase,"main",1,NULL);
#endif */
// Build path list
config_paths_build_list(data);
// Open window
if (!(config_paths_open(data,screen)))
return 0;
// Event loop
FOREVER
{
IPCMessage *imsg;
struct IntuiMessage *msg;
int quit_flag=0;
// IPC messages?
while ((imsg=(IPCMessage *)GetMsg(ipc->command_port)))
{
// Quit?
if (imsg->command==IPC_QUIT)
{
quit_flag=1;
success=0;
}
// Hide?
else if (imsg->command==IPC_HIDE)
{
RemoveAppWindow(data->appwindow);
data->appwindow=0;
CloseConfigWindow(data->window);
data->window=0;
}
// Show?
else if (imsg->command==IPC_SHOW)
{
if (!(config_paths_open(data,imsg->data)))
{
quit_flag=1;
success=0;
}
}
// Activate
else if (imsg->command==IPC_ACTIVATE)
{
if (data->window)
{
WindowToFront(data->window);
ActivateWindow(data->window);
}
}
// Reply
IPC_Reply(imsg);
}
// Any messages to the window?
if (data->window)
{
while ((msg=GetWindowMsg(data->window->UserPort)))
{
struct IntuiMessage msg_copy;
UWORD gadgetid;
// Copy message and reply
msg_copy=*msg;
ReplyWindowMsg(msg);
// Look at message
switch (msg_copy.Class)
{
// Close window
case IDCMP_CLOSEWINDOW:
quit_flag=1;
success=0;
break;
// Gadget
case IDCMP_GADGETUP:
case IDCMP_GADGETDOWN:
// Get GadgetID
gadgetid=((struct Gadget *)msg_copy.IAddress)->GadgetID;
// Look at gadget
switch (gadgetid)
{
// Cancel
case GAD_PATHFORMAT_CANCEL:
success=0;
// Use
case GAD_PATHFORMAT_SAVE:
quit_flag=1;
break;
// Add an entry
case GAD_PATHFORMAT_ADD:
config_paths_add(data,TRUE);
break;
// Change path name
case GAD_PATHFORMAT_PATH:
config_paths_change(data);
break;
// Select an entry
case GAD_PATHFORMAT_PATHS:
{
Att_Node *node;
// Find selected entry
node=Att_FindNode(data->path_list,msg_copy.Code);
// Double-click?
if (DoubleClick(data->seconds,data->micros,msg_copy.Seconds,msg_copy.Micros) &&
node==data->path_sel)
{
// Edit it
config_paths_edit(data);
break;
}
// Store double-click time
data->seconds=msg_copy.Seconds;
data->micros=msg_copy.Micros;
// Not already selected?
if (node!=data->path_sel)
{
// Select it
config_paths_select(data,node,FALSE);
}
}
break;
// Key
case GAD_PATHFORMAT_KEY:
config_paths_get_key(data);
break;
// Open new lister
case GAD_PATHFORMAT_NEW_LISTER:
// Valid selection?
if (data->path_sel)
{
position_rec *pos=(position_rec *)data->path_sel->data;
// Open new lister?
if (msg_copy.Code)
{
// Set flag
pos->flags|=POSITIONF_OPEN_NEW;
// Clear type flags
pos->flags&=~(POSITIONF_ICON|POSITIONF_ICON_ACTION);
// Icon action?
if (msg_copy.Code==MODE_ACTION)
pos->flags|=POSITIONF_ICON|POSITIONF_ICON_ACTION;
// Icon?
else
if (msg_copy.Code==MODE_ICON)
pos->flags|=POSITIONF_ICON;
}
// No lister
else pos->flags&=~POSITIONF_OPEN_NEW;
}
break;
// Remove
case GAD_PATHFORMAT_REMOVE:
config_paths_remove(data,TRUE);
break;
// Edit
case GAD_PATHFORMAT_EDIT:
config_paths_edit(data);
break;
}
break;
// Key press
case IDCMP_RAWKEY:
// Help?
if (msg_copy.Code==0x5f &&
!(msg_copy.Qualifier&VALID_QUALIFIERS))
{
// Valid main IPC?
if (main_ipc)
{
// Set busy pointer
SetWindowBusy(data->window);
// Send help request
IPC_Command(main_ipc,IPC_HELP,(1<<31),"Paths",0,(struct MsgPort *)-1);
// Clear busy pointer
ClearWindowBusy(data->window);
}
}
break;
}
// Check quit flag
if (quit_flag) break;
}
}
// Check quit flag
if (quit_flag) break;
// App messages?
if (data->appport)
{
struct AppMessage *msg;
// Get messages
while ((msg=(struct AppMessage *)GetMsg(data->appport)))
{
// Get first argument
if (msg->am_NumArgs>0)
{
// Is it a directory?
if (!msg->am_ArgList[0].wa_Name || !*msg->am_ArgList[0].wa_Name)
{
char buf[256];
// Expand path name
if (NameFromLock(msg->am_ArgList[0].wa_Lock,buf,256))
{
Att_Node *node;
// Fix trailing /
AddPart(buf,"",256);
// Check it's not already in the list
if (!(node=(Att_Node *)FindNameI((struct List *)data->path_list,buf)))
{
// Add a new entry
config_paths_add(data,FALSE);
// Copy path to path field
SetGadgetValue(data->objlist,GAD_PATHFORMAT_PATH,(ULONG)buf);
// Accept the new path
config_paths_change(data);
}
// It is, select this entry
else config_paths_select(data,node,FALSE);
}
}
}
// Reply message
ReplyMsg((struct Message *)msg);
}
}
// Wait for input
Wait(
((data->window)?(1<<data->window->UserPort->mp_SigBit):0)|
((data->appport)?(1<<data->appport->mp_SigBit):0)|
1<<ipc->command_port->mp_SigBit);
}
// Free stuff
config_paths_cleanup(data);
return success;
}
///
/// HandleIDMCP
PERROR HandleIDCMP( FRAME *frame, struct Objects *o, struct Values *v, struct PPTBase *PPTBase )
{
ULONG sig, sigmask, sigport = 0L;
struct Library *ColorWheelBase = o->ColorWheelBase;
struct IntuitionBase *IntuitionBase = PPTBase->lb_Intuition;
BOOL V39 = FALSE;
if( PPTBase->lb_Gfx->LibNode.lib_Version >= 39 && ColorWheelBase )
V39 = TRUE;
if(StartInput(frame, GINP_PICK_POINT, NULL) == PERR_OK)
sigport = (1 << PPTBase->mport->mp_SigBit);
GetAttr( WINDOW_SigMask, o->Win, &sigmask );
for(;;) {
sig = Wait( sigport|sigmask|SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_F );
if( sig & SIGBREAKF_CTRL_C ) {
SetErrorCode( frame, PERR_BREAK );
DisposeObject( o->Win );
StopInput(frame);
return PERR_BREAK;
}
if( sig & SIGBREAKF_CTRL_F ) {
WindowToFront( o->win );
ActivateWindow( o->win );
}
if( sig & sigport ) {
struct gPointMessage *gp;
gp = (struct gPointMessage*)GetMsg(PPTBase->mport);
/*
* Ignore all other types of messages, except pickpoints.
*/
if( gp->msg.code == PPTMSG_PICK_POINT ) {
D(bug("User picked point (%d,%d)\n",gp->x,gp->y));
if( frame->pix->colorspace == CS_RGB ) {
RGBPixel *cp;
cp = (RGBPixel *)GetPixelRow( frame, gp->y );
SetGadgetAttrs( GAD(o->Red), o->win, NULL, SLIDER_Level, cp[gp->x].r, TAG_DONE );
SetGadgetAttrs( GAD(o->Green), o->win, NULL, SLIDER_Level, cp[gp->x].g, TAG_DONE );
SetGadgetAttrs( GAD(o->Blue), o->win, NULL, SLIDER_Level, cp[gp->x].b, TAG_DONE );
} else {
ARGBPixel *cp;
cp = (ARGBPixel *)GetPixelRow( frame, gp->y );
SetGadgetAttrs( GAD(o->Trans), o->win, NULL, SLIDER_Level, cp[gp->x].a, TAG_DONE );
SetGadgetAttrs( GAD(o->Red), o->win, NULL, SLIDER_Level, cp[gp->x].r, TAG_DONE );
SetGadgetAttrs( GAD(o->Green), o->win, NULL, SLIDER_Level, cp[gp->x].g, TAG_DONE );
SetGadgetAttrs( GAD(o->Blue), o->win, NULL, SLIDER_Level, cp[gp->x].b, TAG_DONE );
}
v->background = FALSE;
}
ReplyMsg( (struct Message *)gp );
}
if( sig & sigmask ) {
ULONG rc, tmp;
struct ColorWheelRGB rgb;
struct ColorWheelHSB hsb;
while(( rc = HandleEvent( o->Win )) != WMHI_NOMORE ) {
switch(rc) {
case WMHI_CLOSEWINDOW:
case GID_CANCEL:
D(bug("User cancelled\n"));
SetErrorCode( frame, PERR_CANCELED );
DisposeObject( o->Win );
StopInput(frame);
return PERR_CANCELED;
/*
* Can't happen if running under <V39, but let's be
* sure anyway
*/
case GID_GRADIENTSLIDER:
if( V39 ) {
GetAttr(GRAD_CurVal, o->RealGradient, &tmp);
// D(bug("New value: %d\n",tmp));
GetAttr( WHEEL_HSB, o->Wheel, (ULONG *)&hsb );
hsb.cw_Brightness = (0xFFFF - tmp) * 0x00010001;
ConvertHSBToRGB( &hsb, &rgb );
SetGadgetAttrs( GAD(o->Red), o->win, NULL, SLIDER_Level, rgb.cw_Red>>24, TAG_DONE );
SetGadgetAttrs( GAD(o->Green), o->win, NULL, SLIDER_Level, rgb.cw_Green>>24, TAG_DONE );
SetGadgetAttrs( GAD(o->Blue), o->win, NULL, SLIDER_Level, rgb.cw_Blue>>24, TAG_DONE );
v->background = FALSE;
}
break;
/*
* Ditto
*/
case GID_WHEEL:
if( V39 ) {
GetAttr( WHEEL_RGB, o->Wheel, (ULONG *) &rgb );
SetGadgetAttrs( GAD(o->Red), o->win, NULL, SLIDER_Level, rgb.cw_Red>>24, TAG_DONE );
SetGadgetAttrs( GAD(o->Green), o->win, NULL, SLIDER_Level, rgb.cw_Green>>24, TAG_DONE );
SetGadgetAttrs( GAD(o->Blue), o->win, NULL, SLIDER_Level, rgb.cw_Blue>>24, TAG_DONE );
v->background = FALSE;
}
break;
case GID_RED:
if( V39 ) {
GetAttr( SLIDER_Level, o->Red, (ULONG *)&tmp );
GetAttr( WHEEL_RGB, o->Wheel, (ULONG *) &rgb );
rgb.cw_Red = tmp * 0x01010101;
SetGadgetAttrs( GAD(o->Wheel), o->win, NULL, WHEEL_RGB, &rgb, TAG_DONE );
v->background = FALSE;
}
break;
case GID_GREEN:
if( V39 ) {
GetAttr( SLIDER_Level, o->Green, (ULONG *)&tmp );
GetAttr( WHEEL_RGB, o->Wheel, (ULONG *) &rgb );
rgb.cw_Green = tmp * 0x01010101;
SetGadgetAttrs( GAD(o->Wheel), o->win, NULL, WHEEL_RGB, &rgb, TAG_DONE );
v->background = FALSE;
}
break;
case GID_BLUE:
if( V39 ) {
GetAttr( SLIDER_Level, o->Blue, (ULONG *)&tmp );
GetAttr( WHEEL_RGB, o->Wheel, (ULONG *) &rgb );
rgb.cw_Blue = tmp * 0x01010101;
SetGadgetAttrs( GAD(o->Wheel), o->win, NULL, WHEEL_RGB, &rgb, TAG_DONE );
v->background = FALSE;
}
break;
case GID_BACKGROUND:
GetBackGround( frame, v, PPTBase );
if( V39 ) {
rgb.cw_Red = v->r * 0x01010101;
rgb.cw_Green = v->g * 0x01010101;
rgb.cw_Blue = v->b * 0x01010101;
SetGadgetAttrs( GAD(o->Wheel), o->win, NULL, WHEEL_RGB, &rgb, TAG_DONE );
DoMethod( o->Win, WM_REPORT_ID, GID_WHEEL, 0L ); // A bug in OS?
} else {
SetGadgetAttrs( GAD(o->Red), o->win, NULL, SLIDER_Level,v->r, TAG_DONE );
SetGadgetAttrs( GAD(o->Green), o->win, NULL, SLIDER_Level,v->g, TAG_DONE );
SetGadgetAttrs( GAD(o->Blue), o->win, NULL, SLIDER_Level,v->b, TAG_DONE );
}
break;
case GID_BLACK:
rgb.cw_Red = rgb.cw_Green = rgb.cw_Blue = 0L;
if( V39 ) {
SetGadgetAttrs( GAD(o->Wheel), o->win, NULL, WHEEL_RGB, &rgb, TAG_DONE );
DoMethod( o->Win, WM_REPORT_ID, GID_WHEEL, 0L ); // A bug in OS?
} else {
SetGadgetAttrs( GAD(o->Red), o->win, NULL, SLIDER_Level,rgb.cw_Red>>24, TAG_DONE );
SetGadgetAttrs( GAD(o->Green), o->win, NULL, SLIDER_Level,rgb.cw_Green>>24, TAG_DONE );
SetGadgetAttrs( GAD(o->Blue), o->win, NULL, SLIDER_Level,rgb.cw_Blue>>24, TAG_DONE );
}
v->background = FALSE;
break;
case GID_WHITE:
rgb.cw_Red = rgb.cw_Green = rgb.cw_Blue = 0xFFFFFFFF;
if (V39 ) {
SetGadgetAttrs( GAD(o->Wheel), o->win, NULL, WHEEL_RGB, &rgb, TAG_DONE );
DoMethod( o->Win, WM_REPORT_ID, GID_WHEEL, 0L ); // A bug in OS?
} else {
SetGadgetAttrs( GAD(o->Red), o->win, NULL, SLIDER_Level,rgb.cw_Red>>24, TAG_DONE );
SetGadgetAttrs( GAD(o->Green), o->win, NULL, SLIDER_Level,rgb.cw_Green>>24, TAG_DONE );
SetGadgetAttrs( GAD(o->Blue), o->win, NULL, SLIDER_Level,rgb.cw_Blue>>24, TAG_DONE );
}
v->background = FALSE;
break;
case GID_OK:
D(bug("User hit OK\n"));
DoGadgets( frame, o, v, PPTBase );
GetAttr( WINDOW_Bounds, o->Win, (ULONG *)&v->window );
DisposeObject( o->Win );
StopInput(frame);
return PERR_OK;
}
}
} /* if(sig&sigmask) */
}
Window::Window(const Rect & rect, int fulls)
{
m_rect = rect;
m_win = 0;
m_init = false;
m_ctx = 0;
//
// Create the Carbon window:
OSStatus s;
if ( fulls ) {
s = CreateNewWindow(kOverlayWindowClass,
kWindowStandardHandlerAttribute | kWindowCompositingAttribute,
&m_rect, &m_win);
if(s != noErr) {
fprintf(stderr,"failed to create window at %i,%i,%i,%i\n",m_rect.left,m_rect.top,m_rect.right,m_rect.bottom);
abort();
}
// Hide Cursor
CGCaptureAllDisplays();
CGDisplayHideCursor(kCGDirectMainDisplay);
CGReleaseAllDisplays();
}
else
{
// just a little offset when opening the window
s = CreateNewWindow(kDocumentWindowClass,
kWindowStandardDocumentAttributes | kWindowStandardHandlerAttribute| kWindowInWindowMenuAttribute,
&m_rect, &m_win);
if(s != noErr) {
fprintf(stderr,"failed to create window at %i,%i,%i,%i\n",m_rect.left,m_rect.top,m_rect.right,m_rect.bottom);
abort();
}
// Put a title
SetWindowTitleWithCFString (m_win, CFSTR("SAGE GStream Receiver"));
}
SetWindowActivationScope(m_win,kWindowActivationScopeAll);
ShowWindow(m_win);
ActivateWindow(m_win, true);
if ( ! fulls ) {
Rect arect;
short hGlobal, vGlobal;
GetWindowBounds(m_win, kWindowStructureRgn, &arect);
MoveWindow (m_win, arect.left, (arect.top < 0) ? 40 : arect.top+50, true);
}
// Create context
m_ctx = aglCreateContext(agl_fmt,0);
if(m_ctx == 0) {
fprintf(stderr,"failed to create OpenGL context\n");
abort();
}
// Set the global context, shared by other windows:
if(agl_ctx == 0) {
agl_ctx = m_ctx;
}
//
// All your window are belong to us:
GLboolean e;
e = aglSetDrawable(m_ctx,GetWindowPort(m_win));
if(!e) {
fprintf(stderr,"failed aglSetDrawable\n");
abort();
}
// Initialize the OpenGL
aglSetCurrentContext(m_ctx);
glViewport(0,0,m_rect.right - m_rect.left,m_rect.bottom - rect.top);
/* glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(m_rect.left,m_rect.right,m_rect.top,m_rect.bottom,-1,1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
*/
glClearColor(0,0,0,1);
glClear(GL_COLOR_BUFFER_BIT);
aglSwapBuffers(m_ctx);
}
int GetConvArgs( FRAME *frame, struct TagItem *tags, struct PPTBase *xd, struct convargs *cargs )
{
Object *Win, *wtgroup, *weights[7][7], *Bias, *Frq, *Name, *Div;
ULONG sigmask, sig, rc;
int quit = FALSE, res = PERR_OK,i,j;
struct Window *win;
struct IntuitionBase *IntuitionBase = xd->lb_Intuition;
struct ExecBase *SysBase = xd->lb_Sys;
struct Library *BGUIBase = xd->lb_BGUI;
char *name = "Unknown";
#ifdef DEBUG_MODE
PDebug("\tCreating window object\n");
#endif
Win = WindowObject,
WINDOW_Screen, xd->g->maindisp->scr,
WINDOW_Title, frame->nd.ln_Name,
WINDOW_Font, xd->g->userprefs->mainfont,
WINDOW_ScreenTitle, "Convolute Tool",
WINDOW_ScaleWidth, 20,
WINDOW_MenuStrip, Menus,
TAG_SKIP, (cargs->winpos.Height == 0) ? 1 : 0,
WINDOW_Bounds, &(cargs->winpos),
WINDOW_NoBufferRP, TRUE,
WINDOW_MasterGroup,
VGroupObject, Spacing(4), HOffset(6), VOffset(4),
StartMember,
Name = InfoFixed("Name:","",NULL,1),
EndMember,
StartMember,
HGroupObject, Spacing(4), HOffset(4),
StartMember,
/* Grid */
wtgroup = VGroupObject,
StartMember,
HGroupObject,
StartMember,
weights[0][0] = Integer(NULL,0,3,GID_W00),
EndMember,
StartMember,
weights[0][1] = Integer(NULL,0,3,GID_W01),
EndMember,
StartMember,
weights[0][2] = Integer(NULL,0,3,GID_W02),
EndMember,
StartMember,
weights[0][3] = Integer(NULL,0,3,GID_W03),
EndMember,
StartMember,
weights[0][4] = Integer(NULL,0,3,GID_W04),
EndMember,
StartMember,
weights[0][5] = Integer(NULL,0,3,GID_W05),
EndMember,
StartMember,
weights[0][6] = Integer(NULL,0,3,GID_W06),
EndMember,
EndObject,
EndMember,
StartMember,
HGroupObject,
StartMember,
weights[1][0] = Integer(NULL,0,3,GID_W10),
EndMember,
StartMember,
weights[1][1] = Integer(NULL,0,3,GID_W11),
EndMember,
StartMember,
weights[1][2] = Integer(NULL,0,3,GID_W12),
EndMember,
StartMember,
weights[1][3] = Integer(NULL,0,3,GID_W13),
EndMember,
StartMember,
weights[1][4] = Integer(NULL,0,3,GID_W14),
EndMember,
StartMember,
weights[1][5] = Integer(NULL,0,3,GID_W15),
EndMember,
StartMember,
weights[1][6] = Integer(NULL,0,3,GID_W16),
EndMember,
EndObject,
EndMember,
StartMember,
HGroupObject,
StartMember,
weights[2][0] = Integer(NULL,0,3,GID_W20),
EndMember,
StartMember,
weights[2][1] = Integer(NULL,0,3,GID_W21),
EndMember,
StartMember,
weights[2][2] = Integer(NULL,0,3,GID_W22),
EndMember,
StartMember,
weights[2][3] = Integer(NULL,0,3,GID_W23),
EndMember,
StartMember,
weights[2][4] = Integer(NULL,0,3,GID_W24),
EndMember,
StartMember,
weights[2][5] = Integer(NULL,0,3,GID_W25),
EndMember,
StartMember,
weights[2][6] = Integer(NULL,0,3,GID_W26),
EndMember,
EndObject,
EndMember,
StartMember,
HGroupObject,
StartMember,
weights[3][0] = Integer(NULL,0,3,GID_W30),
EndMember,
StartMember,
weights[3][1] = Integer(NULL,0,3,GID_W31),
EndMember,
StartMember,
weights[3][2] = Integer(NULL,0,3,GID_W32),
EndMember,
StartMember,
weights[3][3] = Integer(NULL,1,3,GID_W33),
EndMember,
StartMember,
weights[3][4] = Integer(NULL,0,3,GID_W34),
EndMember,
StartMember,
weights[3][5] = Integer(NULL,0,3,GID_W35),
EndMember,
StartMember,
weights[3][6] = Integer(NULL,0,3,GID_W36),
EndMember,
EndObject,
EndMember,
StartMember,
HGroupObject,
StartMember,
weights[4][0] = Integer(NULL,0,3,GID_W40),
EndMember,
StartMember,
weights[4][1] = Integer(NULL,0,3,GID_W41),
EndMember,
StartMember,
weights[4][2] = Integer(NULL,0,3,GID_W42),
EndMember,
StartMember,
weights[4][3] = Integer(NULL,0,3,GID_W43),
EndMember,
StartMember,
weights[4][4] = Integer(NULL,0,3,GID_W44),
EndMember,
StartMember,
weights[4][5] = Integer(NULL,0,3,GID_W45),
EndMember,
StartMember,
weights[4][6] = Integer(NULL,0,3,GID_W46),
EndMember,
EndObject,
EndMember,
StartMember,
HGroupObject,
StartMember,
weights[5][0] = Integer(NULL,0,3,GID_W50),
EndMember,
StartMember,
weights[5][1] = Integer(NULL,0,3,GID_W51),
EndMember,
StartMember,
weights[5][2] = Integer(NULL,0,3,GID_W52),
EndMember,
StartMember,
weights[5][3] = Integer(NULL,0,3,GID_W53),
EndMember,
StartMember,
weights[5][4] = Integer(NULL,0,3,GID_W54),
EndMember,
StartMember,
weights[5][5] = Integer(NULL,0,3,GID_W55),
EndMember,
StartMember,
weights[5][6] = Integer(NULL,0,3,GID_W56),
EndMember,
EndObject,
EndMember,
StartMember,
HGroupObject,
StartMember,
weights[6][0] = Integer(NULL,0,3,GID_W60),
EndMember,
StartMember,
weights[6][1] = Integer(NULL,0,3,GID_W61),
EndMember,
StartMember,
weights[6][2] = Integer(NULL,0,3,GID_W62),
EndMember,
StartMember,
weights[6][3] = Integer(NULL,0,3,GID_W63),
EndMember,
StartMember,
weights[6][4] = Integer(NULL,0,3,GID_W64),
EndMember,
StartMember,
weights[6][5] = Integer(NULL,0,3,GID_W65),
EndMember,
StartMember,
weights[6][6] = Integer(NULL,0,3,GID_W66),
EndMember,
EndObject,
EndMember,
StartMember,
HGroupObject, Spacing(4),
StartMember,
Bias = Integer("Bias:",0,4,GID_BIAS),
EndMember,
StartMember,
Div = Integer("Div:",1,4,GID_DIV),
EndMember,
EndObject,
EndMember,
EndObject, Weight(75),
EndMember,
StartMember,
VGroupObject, Spacing(4),
StartMember,
XenButton("Load",GID_LOAD),
EndMember,
StartMember,
XenButton("Save",GID_SAVE),
EndMember,
StartMember,
XenButton("Clear",GID_CLEAR),
EndMember,
StartMember,
XenButton("Convolute!",GID_OK),
EndMember,
StartMember,
XenButton("Cancel",GID_CANCEL),
EndMember,
EndObject, Weight(10),
EndMember,
EndObject,
EndMember,
EndObject, /* MasterVGroup */
EndObject; /* Window */
if(Win) {
#ifdef DEBUG_MODE
PDebug("\tSucceeded in creating window\n");
#endif
for(i = 0; i < 7; i++) {
for(j = 0; j < 7; j++) {
SetGadgetAttrs( (struct Gadget *)weights[i][j], NULL, NULL,
STRINGA_LongVal, cargs->weights[i][j], TAG_DONE );
}
}
SetGadgetAttrs( (struct Gadget *)Bias, NULL, NULL, STRINGA_LongVal, cargs->bias, TAG_DONE);
SetGadgetAttrs( (struct Gadget *)Div, NULL, NULL, STRINGA_LongVal, cargs->div, TAG_DONE);
SetGadgetAttrs( (struct Gadget *)Name, NULL, NULL, INFO_TextFormat, cargs->name, TAG_DONE);
if( win = WindowOpen( Win ) ) {
#ifdef DEBUG_MODE
PDebug("\tOpened window OK\n");
#endif
Frq = FileReqObject,
ASLFR_Window, win,
ASLFR_SleepWindow, TRUE,
ASLFR_InitialDrawer, "PROGDIR:modules/convolutions",
ASLFR_InitialPattern,"~(#?.info)",
EndObject;
GetAttr( WINDOW_SigMask, Win, &sigmask );
while(!quit) {
sig = Wait(sigmask | SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_F);
/*
* Break signal
*/
if( sig & SIGBREAKF_CTRL_C ) {
quit = TRUE;
res = PERR_BREAK;
}
if( sig & SIGBREAKF_CTRL_F ) {
WindowToFront( win );
ActivateWindow( win );
}
/*
* Gadget message
*/
if( sig & sigmask ) {
while(( rc = HandleEvent( Win )) != WMHI_NOMORE ) {
struct TagItem clrtable[] = { STRINGA_LongVal, 0, TAG_END };
struct TagItem nonametable[] = { INFO_TextFormat, (ULONG)"unnamed", TAG_END };
struct TagItem settable[] = {STRINGA_LongVal, 0, TAG_END };
struct TagItem frqloadtable[] = {ASLFR_DoSaveMode, FALSE, TAG_END };
struct TagItem newnametable[] = {INFO_TextFormat, NULL, TAG_END };
struct TagItem frqsavetable[] = {ASLFR_DoSaveMode, TRUE, TAG_END };
struct TagItem nametable[] = {INFO_TextFormat, NULL, TAG_END };
int id;
switch(rc) {
case WMHI_CLOSEWINDOW:
case GID_CANCEL:
res = PERR_CANCELED;
quit = TRUE;
WindowClose(Win);
break;
case GID_CLEAR:
WindowBusy(Win);
clrtable[0].ti_Data = 0;
SetGadgetAttrsA( (struct Gadget *)Bias, win, NULL, clrtable);
for(i = 0; i < 7; i++) {
for(j = 0; j < 7; j++) {
SetGadgetAttrsA( (struct Gadget *)weights[i][j], win,
NULL, clrtable );
cargs->weights[i][j] = 0;
}
}
clrtable[0].ti_Data = 1; /* For Divisor & Middle value. */
SetGadgetAttrsA( (struct Gadget *)weights[3][3], win,
NULL, clrtable );
cargs->weights[3][3] = 1;
clrtable[0].ti_Data = 1; /* For Divisor */
SetGadgetAttrsA( (struct Gadget *)Div, win, NULL, clrtable);
SetGadgetAttrsA( (struct Gadget *) Name, win, NULL, nonametable);
WindowReady(Win);
break;
case GID_LOAD:
SetAttrsA( Frq, frqloadtable );
if(DoRequest( Frq ) == FRQ_OK) {
GetAttr( FRQ_Path, Frq, (ULONG *)&name );
WindowBusy(Win);
if(LoadConvFilter( xd, name, cargs ) == PERR_OK ) {
for(i = 0; i < 7; i++) {
for(j = 0; j < 7; j++) {
settable[0].ti_Data = cargs->weights[i][j];
SetGadgetAttrsA( (struct Gadget *)weights[i][j], win,
NULL, settable );
}
}
settable[0].ti_Data = cargs->bias;
SetGadgetAttrsA( (struct Gadget *)Bias, win, NULL, settable);
settable[0].ti_Data = cargs->div;
SetGadgetAttrsA( (struct Gadget *)Div, win, NULL, settable);
GetAttr( FRQ_File, Frq, (ULONG *) &newnametable[0].ti_Data );
SetGadgetAttrsA( (struct Gadget *) Name, win, NULL, newnametable);
}
WindowReady(Win);
}
break;
case GID_SAVE:
SetAttrsA( Frq, frqsavetable );
if(DoRequest(Frq) == FRQ_OK) {
WindowBusy(Win);
GetAttr( FRQ_Path, Frq, (ULONG *)&name );
for(i = 0; i < 7; i++) {
for(j = 0; j < 7; j++) {
GetAttr( STRINGA_LongVal, weights[i][j], (ULONG *) &(cargs->weights[i][j]) );
}
}
GetAttr( STRINGA_LongVal, Bias, (ULONG *) &(cargs->bias));
GetAttr( STRINGA_LongVal, Div, (ULONG *) &(cargs->div));
SaveConvFilter( xd, name, cargs );
GetAttr( FRQ_File, Frq, &nametable[0].ti_Data );
SetGadgetAttrsA( (struct Gadget *) Name, win, NULL, nametable);
WindowReady(Win);
}
break;
case GID_OK:
GetAttr( STRINGA_LongVal, Bias, (ULONG *) &(cargs->bias));
GetAttr( STRINGA_LongVal, Div, (ULONG *) &(cargs->div));
GetAttr( WINDOW_Bounds, Win, (ULONG *) &(cargs->winpos) );
if( cargs->div != 0 ) {
WindowClose(Win);
for(i = 0; i < 7; i++) {
for(j = 0; j < 7; j++) {
GetAttr( STRINGA_LongVal, weights[i][j], (ULONG *) &(cargs->weights[i][j]) );
}
}
GetAttr( STRINGA_LongVal, Bias, (ULONG *) &(cargs->bias));
GetAttr( STRINGA_LongVal, Div, (ULONG *) &(cargs->div));
strncpy( cargs->name, name, 40 );
res = PERR_OK;
quit = TRUE;
}
break;
default:
if(rc >= OPR(0) && rc <= OPR(1000)) { /* It's a default opr */
WindowBusy(Win);
for(id = 0; presets[id].id != rc && presets[id].id != 0L; id++); /* Fetch correct area. */
if(presets[id].id) {
for(i = 0; i < 7; i++) {
for(j = 0; j < 7; j++) {
settable[0].ti_Data = cargs->weights[i][j] = presets[id].weights[i][j];
SetGadgetAttrsA( (struct Gadget *)weights[i][j], win,
NULL, settable );
}
}
settable[0].ti_Data = cargs->bias = presets[id].bias;
SetGadgetAttrsA( (struct Gadget *)Bias, win, NULL, settable);
settable[0].ti_Data = cargs->div = presets[id].div;
SetGadgetAttrsA( (struct Gadget *)Div, win, NULL, settable);
newnametable[0].ti_Data = name = (ULONG)presets[id].name;
SetGadgetAttrsA( (struct Gadget *)Name, win, NULL, newnametable);
}
#ifdef DEBUG_MODE
else {
PDebug("Serious software error!!!\n");
}
#endif
WindowReady(Win);
}
break;
} /* switch */
} /* while */
} /* sig & sigmask */
} /* while(!quit) */
DisposeObject(Win);
DisposeObject(Frq);
} else {
#ifdef DEBUG_MODE
PDebug("\tFailed to get window\n");
#endif
DisposeObject(Win);
return PERR_WONTOPEN;
}
} else {
#ifdef DEBUG_MODE
PDebug("\tFailed to get window object\n");
#endif
return PERR_WONTOPEN;
}
return res;
}
EFFECTEXEC(frame,tags,PPTBase,EffectBase)
{
ULONG sig, rc, *args;
BOOL quit = FALSE, reallyrexx = FALSE;
FRAME *newframe = NULL, *with = NULL;
struct gFixRectMessage gfr = {0};
ULONG fc, wc;
struct Values *av;
D(bug(MYNAME": Exec()\n"));
/*
* Defaults
*/
v.ratio = 128;
v.method = Direct;
v.bounds.Top = v.bounds.Left = ~0;
v.bounds.Width = 200; v.bounds.Height = 100;
v.tile = FALSE;
if( av = GetOptions(MYNAME) ) {
v = *av;
}
/*
* Copy to local variables
*/
BGUIBase = PPTBase->lb_BGUI;
IntuitionBase = (struct IntuitionBase *)PPTBase->lb_Intuition;
DOSBase = PPTBase->lb_DOS;
SysBase = PPTBase->lb_Sys;
/*
* Parse AREXX message, which has to exist.
* BUG: If necessary, should wait for D&D from the main window.
* BUG: Should make sanity checks!
*/
args = (ULONG *) TagData( PPTX_RexxArgs, tags );
if( args ) {
/* WITH */
if( args[0] ) {
with = FindFrame( (ID) PEEKL(args[0]) );
if(!with) {
SetErrorMsg(frame,"Unknown frame ID for WITH parameter");
return NULL;
}
}
/* TOP */
if( args[1] ) {
gfr.y = (WORD) PEEKL(args[1]);
reallyrexx = TRUE;
}
/* LEFT */
if( args[2] ) {
gfr.x = (WORD) PEEKL(args[2]);
reallyrexx = TRUE;
}
/* METHOD */
if( args[3] ) {
int i;
for( i = 0; method_labels[i]; i++ ) {
if(stricmp( method_labels[i], (char *)args[3] ) == 0 ) {
v.method = i;
reallyrexx = TRUE;
break;
}
}
}
/* RATIO */
if( v.method == Mix ) {
if( args[4] ) {
v.ratio = PEEKL( args[4] );
} else {
SetErrorCode(frame,PERR_INVALIDARGS);
}
}
/* TILE */
if( args[5] ) {
v.tile = TRUE;
} else {
v.tile = FALSE;
}
} else {
SetErrorMsg(frame,"Image compositing can be used with Drag&Drop (or REXX) only");
return NULL;
}
/*
* Make some sanity checks
*/
if( frame->pix->width < with->pix->width ||
frame->pix->height < with->pix->height ) {
SetErrorMsg(frame,"You cannot composite a larger picture on a smaller one!");
return NULL;
}
fc = frame->pix->colorspace;
wc = with->pix->colorspace;
if( ! (wc == fc || (fc == CS_ARGB && wc == CS_RGB) || (fc == CS_RGB && wc == CS_ARGB ))) {
SetErrorMsg(frame, "Only images of the same color space can be composited");
return NULL;
}
gfr.dim.Left = 0;
gfr.dim.Top = 0;
gfr.dim.Height = with->pix->height;
gfr.dim.Width = with->pix->width;
/*
* Open window and start parsing
*/
if( reallyrexx == FALSE ) {
if( GimmeWindow(frame, with, PPTBase) ) {
ULONG sigmask, gimask = 0L;
GetAttr( WINDOW_SigMask, Win, &sigmask );
StartInput(frame, GINP_FIXED_RECT, (struct PPTMessage *) &gfr);
gimask = (1 << PPTBase->mport->mp_SigBit);
while( !quit ) {
sig = Wait( sigmask|gimask|SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_F );
if( sig & SIGBREAKF_CTRL_C ) {
D(bug("BREAK!\n"));
SetErrorCode( frame, PERR_BREAK );
quit = TRUE;
break;
}
if( sig & SIGBREAKF_CTRL_F ) {
WindowToFront(win);
ActivateWindow(win);
}
if( sig & gimask ) {
struct gFixRectMessage *pmsg;
if(pmsg = (struct gFixRectMessage *)GetMsg( PPTBase->mport )) {
if( pmsg->msg.code == PPTMSG_FIXED_RECT ) {
D(bug("User picked a point @ (%d,%d)\n",pmsg->x, pmsg->y));
gfr.x = pmsg->x; gfr.y = pmsg->y;
// SetGadgetAttrs( ( struct Gadget *)OKButton, win, NULL, GA_Disabled, FALSE );
}
ReplyMsg( (struct Message *)pmsg );
}
}
if( sig & sigmask ) {
while( (rc = HandleEvent( Win )) != WMHI_NOMORE ) {
ULONG t;
switch(rc) {
case GID_OK:
GetAttr( CYC_Active, Method, (ULONG *)&v.method );
GetAttr( SLIDER_Level, Ratio, &v.ratio );
/*
* Save the window attributes for later retrieval.
*/
GetAttr( WINDOW_Bounds, Win, (ULONG *) &v.bounds );
GetAttr( GA_Selected, Tile, &t );
StopInput( frame );
v.tile = (BOOL) t;
WindowClose(Win);
newframe = DoComposite( frame, with, &gfr, v.method,
(WORD) v.ratio, v.tile, PPTBase );
quit = TRUE;
break;
case GID_CANCEL:
quit = TRUE;
StopInput( frame );
break;
}
}
}
}
}
} else {
/* gfr is already set up */
newframe = DoComposite( frame, with, &gfr,
v.method, (WORD) v.ratio, v.tile,
PPTBase );
}
if(Win) DisposeObject(Win);
if( newframe ) {
PutOptions( MYNAME, &v, sizeof(struct Values) );
}
D(bug("Returning %08X...\n",newframe));
return newframe;
}
