bool CDocCommands::OpenImage()
{
CWaitCursor Wait;
LPCTSTR pstrFilter = (CImage::IsGdiPlusInstalled() ? FILTER_WITH_GDIPLUS : FILTER_WITHOUT_GDIPLUS);
CFileDialog FileDialog(true, _T("jpg"), NULL/*pszFileName*/,
OFN_EXPLORER | OFN_ENABLESIZING | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT,
pstrFilter, m_DocWindow/*hWndParent*/);
FileDialog.m_ofn.lpstrTitle = _T("Open an Image File");
if (FileDialog.DoModal(m_DocWindow) == IDCANCEL)
return false;
CString strFileName = FileDialog.m_ofn.lpstrFile;
// Save the path in the registry
//j if (regkey.m_hKey)
//j bool bOK = (regkey.SetStringValue(REGVAL_MRU_PICTURE_PATH, StrPath(szFileName)) == ERROR_SUCCESS);
// Redraw the window underneath, before we get to work
::UpdateWindow(m_DocWindow);
if (SINGLE_IMAGE_EDITOR)
{ // Close the existing image if you want to a single image editor
if (m_DocWindow.GetSelectedObject())
CloseImage();
}
CImageObject* pObject = m_DocWindow.OpenImage(strFileName, NULL/*pDib*/, NULL/*pMatrix*/);
if (!pObject)
return false;
return true;
}
bool CDocCommands::FileTab(CString& strCommand)
{
if (strCommand == "OPEN")
return OpenImage();
if (strCommand == "CLOSE")
return CloseImage();
if (strCommand == "SAVE")
return SaveImage();
return false;
}
bool CDocCommands::OpenImageEx(BITMAPINFOHEADER* pDIB)
{
if (SINGLE_IMAGE_EDITOR)
{ // Close the existing image if you want to a single image editor
if (m_DocWindow.GetSelectedObject())
CloseImage();
}
CImageObject* pObject = m_DocWindow.OpenImage(NULL/*pszFileName*/, pDIB, NULL/*pMatrix*/);
if (!pObject)
return false;
return true;
}
void CImage::Close()
{
if (!gnDecoderThreadId || GetCurrentThreadId() == gnDecoderThreadId)
{
CloseImage();
}
CloseDisplay();
// Удалить указатели на страницы
if (mp_Pages)
{
delete mp_Pages;
mp_Pages = NULL;
}
}
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);
}
BOOL HandleCommandLine( HWND hWindow, LPTSTR lpszCmdLine, LPINT lpPrint )
/***********************************************************************/
{
FNAME szFileName;
LPTSTR lp;
BOOL bPassedByClient;
LPIMAGE lpImageDoc;
HWND hWnd;
WORD wChar;
*lpPrint = NO;
if( !lpszCmdLine )
return( TRUE );
// Check if we have "[/ | -]embedding" and a possible filename.
// usage: PP ["[-/]embedding"] file1 file2 ...
//dbg("full command line = '%ls'", lpszCmdLine );
// See if the command line is being passed by a client
bPassedByClient = NO;
if(( lp = lstrfind( lpszCmdLine, _T("embedding") )) &&
( lp == lpszCmdLine || lp == ( MyCharNext( lpszCmdLine ))))
{ // Command line passed by a client
// dbg(_T("command line passed by client"));
bPassedByClient = YES;
lpszCmdLine = SkipSpaces( MyCharNextN( lp, 9 )); // skip over _T("embedding")
}
while( *lpszCmdLine ) // Process any files and switches on the command line
{
// Skip white space and see if we're done...
lpszCmdLine = SkipSpaces( lpszCmdLine );
if( !( *lpszCmdLine )) // If NULL get out
break;
// dbg( _T("file='%ls' print=%d"), lpszCmdLine, *lpPrint );dbg(0);
// Check for any switches preceeding the file name: only /p for now
while( TRUE )
{
if( IsDBCSLeadByte(( BYTE )*lpszCmdLine ))
wChar = *(( LPWORD )lpszCmdLine );
else
wChar = *lpszCmdLine;
if( wChar != _T('/')) // if not a switch...
break;
lpszCmdLine = MyCharNext( lpszCmdLine ); // Skip over the slash
if( !*lpszCmdLine ) // If NULL get out
break;
if( IsDBCSLeadByte(( BYTE )*lpszCmdLine ))
wChar = *(( LPWORD )lpszCmdLine );
else
wChar = *lpszCmdLine;
if( wChar == _T('p') || wChar == _T('P') )
*lpPrint = YES;
lpszCmdLine = SkipSpaces( MyCharNext( lpszCmdLine ));
}
// Skip white space and see if we're done...
lpszCmdLine = SkipSpaces( lpszCmdLine );
if( !( *lpszCmdLine )) // If NULL get out
break;
// Try to zap the space after a single file name
if(( lp = lstrfind( lpszCmdLine, _T(" ") )))
*lp = _T('\0'); // If we found a space, zap it
// Copy the full path name into szFileName
if( lStrChr( lpszCmdLine, _T('\\') ))
lstrcpy( szFileName, lpszCmdLine );
else // If not a full path name...
{
GetCurrentDir( szFileName, sizeof(FNAME) );
FixPath( szFileName );
lstrcat( szFileName, lpszCmdLine );
}
// Now we're done with lpszCmdLine, so set it up for the next loop
// If we had found a space, there might be more file names
if( lp )
lpszCmdLine = MyCharNext( lp );
else
lpszCmdLine += lstrlen( lpszCmdLine ); // Point to nothing
// Process szFileName
// Special handling of documents passed by a client
if ( bPassedByClient )
{
CServerDoc *pDoc = PictPubApp.GetDocument(szFileName);
if (pDoc)
{
// It's already open....
POSITION ViewPos = pDoc->GetFirstViewPosition();
ASSERT(ViewPos!=NULL);
CView* pView = pDoc->GetNextView( ViewPos );
ASSERT(pView);
// NOTE send Message to View's Parent MDIFrame
SendMessage( PictPubApp.Get_hClientAstral(), WM_MDIACTIVATE,
(WORD)pView->GetParentFrame()->GetSafeHwnd(), 0L );
lpImageDoc->fOwnedByClient = YES;
*szFileName = _T('\0'); // Zap it
}
}
// If we have a file name, open it...
if ( *szFileName )
hWnd = AstralImageLoad( 0, szFileName, MAYBE, YES );
else
hWnd = NULL;
// If the printing option was passed, print it and close it
if ( hWnd && *lpPrint )
{
FORWARD_WM_COMMAND(PictPubApp.Get_hWndAstral(), IDM_PRINT, NULL, 0, SendMessage);
CloseImage( NO, NULL, NULL );
}
}
return( TRUE );
}
// Quit the program
void quit(BOOL script)
{
// If main status window is open, close it
if (main_status)
{
CloseProgressWindow(main_status);
main_status=0;
}
if (GUI)
{
// Clear 'startup' flag for scripts
GUI->flags&=~GUIF_DONE_STARTUP;
// Close commodities
cx_remove(GUI->cx);
// Update environment settings
env_update_settings(1);
// Stop notify request
RemoveNotifyRequest(GUI->notify_req);
GUI->notify_req=0;
// Is there a hide appicon?
if (GUI->hide_appicon)
{
RemoveAppIcon(GUI->hide_appicon);
FreeCachedDiskObject(GUI->hide_diskobject);
}
// Or an appmenuitem?
if (GUI->hide_appitem) RemoveAppMenuItem(GUI->hide_appitem);
// Launch shutdown script
if (script)
RunScript(SCRIPT_SHUTDOWN,0);
// Set quit flag
GUI->flags|=GUIF_PENDING_QUIT;
// Shut the display down
close_display(CLOSE_ALL,TRUE);
// Send quit notifications
quit_notify();
// Stop notifications
stop_file_notify(GUI->pattern_notify);
stop_file_notify(GUI->font_notify);
stop_file_notify(GUI->modules_notify);
stop_file_notify(GUI->commands_notify);
stop_file_notify(GUI->env_notify);
stop_file_notify(GUI->desktop_notify);
stop_file_notify(GUI->filetype_notify);
// Free application port
if (GUI->appmsg_port)
{
DOpusAppMessage *amsg;
RemPort(GUI->appmsg_port);
while ((amsg=(DOpusAppMessage *)GetMsg(GUI->appmsg_port)))
ReplyAppMessage(amsg);
DeleteMsgPort(GUI->appmsg_port);
GUI->appmsg_port=0;
// Remove public semaphore
RemSemaphore((struct SignalSemaphore *)&pub_semaphore);
}
// Flush IPC port
IPC_Flush(&main_ipc);
// Close all processes
IPC_ListQuit(&GUI->lister_list,&main_ipc,0,TRUE);
IPC_ListQuit(&GUI->group_list,&main_ipc,0,TRUE);
IPC_ListQuit(&GUI->buttons_list,&main_ipc,0,TRUE);
IPC_ListQuit(&GUI->startmenu_list,&main_ipc,0,TRUE);
IPC_ListQuit(&GUI->process_list,&main_ipc,0,TRUE);
IPC_ListQuit(&GUI->function_list,&main_ipc,0,TRUE);
// Free buffers
buffers_clear(0);
// Remove all handlers
RemFunctionTrap("*","#?");
// Free filetypes
FreeMemHandle(GUI->filetype_memory);
// Flush the filetype cache
ClearFiletypeCache();
// Free lister toolbar
FreeToolBar(GUI->toolbar);
// Free menus and hotkeys
CloseButtonBank(GUI->lister_menu);
CloseButtonBank(GUI->hotkeys);
// Free user menus
CloseButtonBank(GUI->user_menu);
FreeVec(GUI->user_menu_data);
// Free backdrop list
backdrop_free(GUI->backdrop);
// Free icons
if (GUI->lister_icon) FreeCachedDiskObject(GUI->lister_icon);
if (GUI->button_icon) FreeCachedDiskObject(GUI->button_icon);
// Free arrow image
CloseImage(GUI->toolbar_arrow_image);
#ifdef __amigaos3__
FreeVec(arrow_hi_data_chip);
FreeVec(arrow_lo_data_chip);
FreeVec(small_arrow_chip);
FreeVec(big_arrow_chip);
#ifndef USE_SCREENTITLE
FreeVec(moon_big_data_chip);
FreeVec(moon_small_data_chip);
#endif
FreeVec(command_arrow_chip);
FreeVec(parent_arrow_chip);
#endif
// Free screen signal
if (GUI->screen_signal!=-1) FreeSignal(GUI->screen_signal);
// Delete notify port
if (GUI->notify_port) DeleteMsgPort(GUI->notify_port);
// Free position memory
FreeMemHandle(GUI->position_memory);
// Free command history
Att_RemList(GUI->command_history,0);
// Delete icon positioning port
DeleteMsgPort(GUI->iconpos_port);
// Free popup menu
PopUpFreeHandle(GUI->desktop_menu);
// Clear requester pattern hook in library
if (GUI->flags2&GUIF2_BACKFILL_SET)
SetReqBackFill(0,0);
}
// Free scripts
FreeScripts();
// Free environment
environment_free(environment);
// Delete main message ports
IPC_Flush(&main_ipc);
DeleteMsgPort(main_ipc.command_port);
DeleteMsgPort(main_ipc.reply_port);
// Pause here for a couple of seconds to let everything clean up
Delay(3*50);
// Free global data
FreeMemHandle(global_memory_pool);
// Delete any temporary files
delete_temp_files(0);
// Free locale data
free_locale_data(&locale);
// Close input device
if (InputBase) {
#ifdef __amigaos4__
DropInterface((struct Interface *)IInput);
#endif
CloseDevice((struct IORequest *)&input_req);
}
// Close timer device
if (TimerBase) {
#ifdef __amigaos4__
DropInterface((struct Interface *)ITimer);
#endif
CloseDevice((struct IORequest *)&timer_req);
}
// Close console device
if (ConsoleDevice) {
#ifdef __amigaos4__
DropInterface((struct Interface *)IConsole);
#endif
CloseDevice((struct IORequest *)&console_req);
}
// Close libraries
#ifdef __amigaos4__
DropInterface((struct Interface *)Imu);
#endif
CloseLibrary(muBase);
#ifndef __amigaos3__
#ifdef __amigaos4__
DropInterface((struct Interface *)INewIcon);
#endif
CloseLibrary((struct Library *)NewIconBase);
#endif
#ifdef __amigaos4__
DropInterface((struct Interface *)ICyberGfx);
#endif
CloseLibrary(CyberGfxBase);
#ifdef __amigaos4__
DropInterface((struct Interface *)IAmigaGuide);
#endif
CloseLibrary(AmigaGuideBase);
#ifdef __amigaos4__
DropInterface((struct Interface *)IDataTypes);
#endif
CloseLibrary(DataTypesBase);
#ifdef __amigaos4__
DropInterface((struct Interface *)IAsl);
#endif
CloseLibrary(AslBase);
#ifdef __amigaos4__
DropInterface((struct Interface *)IIcon);
#endif
CloseLibrary(IconBase);
#ifdef __amigaos4__
DropInterface((struct Interface *)IDiskfont);
#endif
CloseLibrary(DiskfontBase);
#ifdef __amigaos4__
DropInterface((struct Interface *)IWorkbench);
#endif
CloseLibrary(WorkbenchBase);
#ifdef __amigaos4__
DropInterface((struct Interface *)ICommodities);
#endif
CloseLibrary(CxBase);
#ifdef __amigaos4__
DropInterface((struct Interface *)IRexxSys);
#endif
CloseLibrary((struct Library *)RexxSysBase);
#ifdef __amigaos4__
DropInterface((struct Interface *)IUtility);
#endif
CloseLibrary(UtilityBase);
#ifdef __amigaos4__
DropInterface((struct Interface *)IGadTools);
#endif
CloseLibrary(GadToolsBase);
#ifdef __amigaos4__
DropInterface((struct Interface *)ILayers);
#endif
CloseLibrary((struct Library *)LayersBase);
#ifdef __amigaos4__
DropInterface((struct Interface *)IGraphics);
#endif
CloseLibrary((struct Library *)GfxBase);
#ifdef __amigaos4__
DropInterface((struct Interface *)IIntuition);
#endif
CloseLibrary((struct Library *)IntuitionBase);
// Restore old current directory?
if (old_current_dir)
{
UnLock(CurrentDir(old_current_dir));
}
// Close the dopus5.library
#ifdef __amigaos4__
DropInterface((struct Interface *)IDOpus);
#endif
CloseLibrary(DOpusBase);
// Outahere!
exit(0);
}
BOOL HandleCommandLine(
/***********************************************************************/
HWND hWindow,
LPSTR lpszCmdLine,
LPINT lpPrint)
{
FNAME szFileName;
LPSTR lp;
BOOL bPassedByClient, bGotImage;
LPIMAGE lpImageDoc;
HWND hWnd;
int i;
bPaintAppActive = TRUE;
*lpPrint = NO;
if ( !lpszCmdLine )
{ // If no command line, bring up an empty image
SendMessage( hWindow, WM_COMMAND, IDM_NEW, 0L );
if ( (hWnd = AstralDlgGet(IDD_MAIN)) && !IsWindowVisible( hWnd ) )
ShowWindow( hWnd, SW_SHOW );
return( TRUE );
}
// Check if we have "[/ | -]embedding" and a possible filename.
// usage: PP ["[-/]embedding"] file1 file2 ...
// See if the command line is being passed by a client
bPassedByClient = NO;
if ( (lp = lstrfind( lpszCmdLine, "embedding" )) &&
(lp == lpszCmdLine || lp == (lpszCmdLine+1)) )
{ // Command line passed by a client
bPassedByClient = YES;
lpszCmdLine = SkipSpaces( lp + 9 ); // skip over "embedding"
}
bGotImage = NO;
while ( *lpszCmdLine )
{ // Process any files and switches on the command line
// Skip white space and see if we're done...
lpszCmdLine = SkipSpaces( lpszCmdLine );
if ( !(*lpszCmdLine ) )
break; // If NULL get out
// Check for any switches preceeding the file name: only /p for now
while ( *lpszCmdLine == '/' )
{ // a switch...
lpszCmdLine++; // Skip over the slash
if ( !*lpszCmdLine )
break; // If NULL get out
if ( *lpszCmdLine == 'p' || *lpszCmdLine == 'P' )
*lpPrint = YES;
lpszCmdLine++; // Skip the option character
lpszCmdLine = SkipSpaces( lpszCmdLine );
}
// Skip white space and see if we're done...
lpszCmdLine = SkipSpaces( lpszCmdLine );
if ( !(*lpszCmdLine ) )
break; // If NULL get out
// Try to zap the space after a single file name
if ( (lp = lstrfind( lpszCmdLine, " " )) )
*lp = '\0'; // If we found a space, zap it
// Copy the full path name into szFileName
#ifdef _MAC
lstrcpy( szFileName, lpszCmdLine );
#else
if ( lstrchr( lpszCmdLine, '\\' ) )
lstrcpy( szFileName, lpszCmdLine );
else
{ // If not a full path name...
GetCurrentDir( szFileName, sizeof(FNAME) );
FixPath( szFileName );
lstrcat( szFileName, lpszCmdLine );
}
#endif
// Now we're done with lpszCmdLine, so set it up for the next loop
if ( lp ) // If we had found a space, there might be more file names
lpszCmdLine = lp + 1;
else lpszCmdLine += lstrlen(lpszCmdLine); // Point to nothing
// Special handling of documents passed by a client
////if ( bPassedByClient )
//// { // Loop through documents to see if it's already open
for ( i=0; i<NumDocs(); i++ )
{
hWnd = GetDoc(i);
if ( !(lpImageDoc = (LPIMAGE)GetWindowLong( hWnd, GWL_IMAGEPTR )))
continue;
if ( !StringsEqual( lpImageDoc->CurFile, szFileName ) )
continue;
// It's already open....
SendMessage( hClientAstral, WM_MDIACTIVATE, (WPARAM)hWnd, 0L );
if ( bPassedByClient )
lpImageDoc->fOwnedByClient = YES;
szFileName[0] = '\0'; // Zap it
bGotImage = YES;
break;
}
//// }
// If we have a file name, open it...
if ( *szFileName )
{
if ( AstralImageLoad( NULL, szFileName, MAYBE, YES ) )
bGotImage = YES;
}
// If the printing option was passed, print it and close it
if ( *lpPrint && lpImage )
{
SendMessage(hWndAstral, WM_COMMAND, IDM_PRINT, 0L );
CloseImage( NO, NULL );
}
}
if ( !bGotImage )
{
if ( !idCurrentRoom )
{
GoRoom (hInstAstral, -1, FALSE);
return( FALSE );
}
// If no image was opened via the command line, go to the opening screen
SendMessage( hWindow, WM_COMMAND, IDM_NEW, 0L );
}
if ( (hWnd = AstralDlgGet(IDD_MAIN)) && !IsWindowVisible( hWnd ) )
ShowWindow( hWnd, SW_SHOW );
return( TRUE );
}
long DoCommand( HWND hWindow, WPARAM wParam, LPARAM lParam )
/***********************************************************************/
{
FNAME szFileName;
LPFRAME lpFrame;
LPOBJECT lpObject, lpBase;
RECT rect, rMask, rTemp, rAll;
HWND hWnd;
STRING szString;
int i, idFileType, x, y, dx, dy;
BOOL fDoZoom, bPrint, fHasZoom;
LPSTR lpszCmdLine;
HGLOBAL hMem;
ITEMID idDataType;
DWORD dwReturn;
int NewShape;
UINT wID;
SoundStartID( wParam, NO/*bLoop*/, NULL/*hInstance*/ );
/*
WIN16: ID = wParam
ctrl handle = LOWORD(lParam)
notify code = HIWORD(lParam)
WIN32: ID = LOWORD(wParam)
ctrl handle = lParam
notify code = HIWORD(wParam)
*/
#ifdef WIN32
wID = LOWORD(wParam);
#else
wID = wParam;
#endif
switch (wID)
{
case IDM_EXIT:
DeactivateTool();
PostMessage( hWndAstral, WM_CLOSE, 0, 0L);
Delay (750);
break;
case IDM_CLOSE:
DeactivateTool();
/* Check to see if the image needs to be saved */
if ( !ConfirmClose(NO,NO) )
break;
CloseImage( NO, lpImage ); // Close the active image
break;
case IDM_ABOUT:
/* Bring up the modal 'About' dialog box */
AstralDlg( NO|2, hInstAstral, hWindow, IDD_ABOUT, DlgAboutProc);
break;
case IDM_NEXTPAGE:
if ( !lpImage )
break;
DeactivateTool();
SendMessage( lpImage->hWnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0L );
break;
case IDM_NEW:
DeactivateTool();
SoundStartResource( "magic01", NO, NULL );
AstralCursor( IDC_WAIT );
New( Control.NewWidth, Control.NewHeight, Control.NewResolution,
Control.NewDepth );
AstralCursor( NULL );
break;
case IDM_OPEN:
DeactivateTool();
/* Bring up the modal 'File Open' box */
if ( !(dwReturn = DoOpenDlg( hWindow, IDD_OPEN,
Save.FileType, szFileName, NO )) )
break;
idFileType = LOWORD( dwReturn );
Save.FileType = idFileType;
PutDefaultInt( "FileType", idFileType - IDN_TIFF );
AstralImageLoad( idFileType, szFileName, MAYBE, YES );
break;
case IDM_ALTOPEN:
DeactivateTool();
// Command line sent from a second instance prior to it closing
/* If the caller passed in a file name, try to load it or print it */
if ( !(lpszCmdLine = (LPSTR)lParam) )
break;
HandleCommandLine( hWindow, lpszCmdLine, &bPrint );
break;
case IDM_SAVE:
DeactivateTool();
HandleSaveCommand(hWindow, wID, YES);
break;
case IDM_SAVEAS:
DeactivateTool();
HandleSaveCommand(hWindow, wID, YES);
break;
case IDM_SAVESPECIAL:
DeactivateTool();
HandleSaveCommand(hWindow, wID, YES);
break;
case IDM_SAVEWALLPAPER:
DeactivateTool();
SaveWallpaper( "CRAYOLA", NO/*fTiled*/ );
break;
case IDM_REVERT:
if ( !lpImage )
break;
DeactivateTool();
if ( lpImage->fUntitled ) // If the picture doesn't have a name, get out
break;
if ( ImgChanged(lpImage) )
{
/* Check to see if its OK to trash changes */
if ( AstralOKCancel(IDS_OKTOREVERT,
(LPSTR)lpImage->CurFile) == IDCANCEL )
break;
}
lstrcpy( szFileName, lpImage->CurFile );
idFileType = lpImage->FileType;
fDoZoom = IsZoomed(lpImage->hWnd);
fHasZoom = Window.fHasZoom;
CloseImage( NO, lpImage ); // Close the active image
if ( !AstralImageLoad( idFileType, szFileName, fDoZoom, YES ) )
break;
break;
case IDM_RECALLIMAGE0:
case IDM_RECALLIMAGE1:
case IDM_RECALLIMAGE2:
case IDM_RECALLIMAGE3:
case IDM_RECALLIMAGE4:
case IDM_RECALLIMAGE5:
case IDM_RECALLIMAGE6:
case IDM_RECALLIMAGE7:
case IDM_RECALLIMAGE8:
case IDM_RECALLIMAGE9:
DeactivateTool();
GetMenuString( GetMenu(hWindow), wID,
szFileName, sizeof(szFileName), MF_BYCOMMAND );
i = 0;
while ( szFileName[i] && szFileName[i] != ' ' )
i++; // Skip over the numeric id in the string (3. junk.tif)
lstrcpy(szString, &szFileName[i+1]);
GetRecallFileName(szString);
AstralImageLoad( NULL, szString, MAYBE, YES );
break;
case IDM_PRINT:
if ( !lpImage )
break;
DeactivateTool();
AstralCursor( IDC_WAIT );
DoPrintSizeInits();
SoundStartResource( "print", YES, NULL );
PrintFile( hWindow, filename(lpImage->CurFile), YES, lpImage, NULL );
SoundStop();
AstralCursor( NULL );
break;
case IDM_PRINTSETUP:
/* Bring up the setup dialog box for the active printer */
AstralDlg( NO|2, hInstAstral, hWindow, IDD_PRINTSETUP,
DlgPrintSetupProc);
break;
case IDC_SOUND:
SoundToggle();
break;
case IDM_UNDO:
if ( !lpImage )
break;
DeactivateTool();
ImgEditUndo(lpImage, YES, NO);
break;
case IDM_CUT:
case IDM_COPY:
if ( !lpImage )
break;
DeactivateTool();
// Create the clipboard files from the image
ProgressBegin(1, IDS_PROGCOPY);
if ( !ImgWriteClipOut( lpImage, NULL, NULL, &rMask, lpImage->DataType ) )
{
ProgressEnd();
Message(IDS_EMEMALLOC);
break;
}
ProgressEnd();
OpenClipboard(hWindow);
EmptyClipboard();
// Passing a NULL data handle in SetClipboardData() means that
// the data will be requested in a WM_RENDERFORMAT message
hMem = ConstructObject( lpImage,
IsRectEmpty(&rMask)? (LPRECT)NULL : (LPRECT)&rMask );
if ( pOLE )
{ // Any data put on before Native will become staticly copied
SetClipboardData( pOLE->cfNative, NULL );
SetClipboardData( pOLE->cfOwnerLink, hMem );
}
SetClipboardData( CF_DIB, NULL );
if ( Control.DoPicture )
SetClipboardData( CF_METAFILEPICT, NULL );
if ( Control.DoBitmap )
SetClipboardData( CF_BITMAP, NULL );
SetClipboardData( CF_PALETTE, NULL );
SetClipboardData( Control.cfImage, NULL );
if ( pOLE && wID == IDM_COPY && !lpImage->fUntitled )
{ // ObjectLink is retrieved during a Paste Link...
SetClipboardData( pOLE->cfObjectLink, hMem );
}
CloseClipboard();
if ( wID == IDM_COPY )
break;
// else fall through to IDM_DELETE
case IDM_DELETE:
if ( !lpImage )
break;
{
COLORINFO ColorInfo;
DeactivateTool();
ColorInfo.gray = 255;
SetColorInfo( &ColorInfo, &ColorInfo, CS_GRAY );
TintFill( lpImage, &ColorInfo, 255, MM_NORMAL,
wID == IDM_CUT ? IDS_UNDOCUT : IDS_UNDODELETE );
}
break;
case IDM_PASTE:
if ( !lpImage )
break;
case IDM_PASTEASNEW:
if ( !OpenClipboard(hWndAstral) )
{
Message( IDS_ECLIPOPEN );
break;
}
if ( !IsClipboardFormatAvailable(CF_DIB) &&
!IsClipboardFormatAvailable(CF_BITMAP) &&
!IsClipboardFormatAvailable(Control.cfImage) )
{
Message( IDS_ECLIPOPEN );
CloseClipboard();
break;
}
CloseClipboard();
DeactivateTool();
// First put clipboard contents into a file(s)
AstralCursor(IDC_WAIT);
if ( !PasteFromClipboard( hWindow, (wID == IDM_PASTE) /*fNeedMask*/ ) )
{
AstralCursor(NULL);
Message(IDS_EMEMALLOC);
break;
}
if ( wID == IDM_PASTE )
{
ProgressBegin(1, IDS_PROGPASTECLIP);
TransformObjectsStart( YES/*fNewObject*/ );
if ( ImgCreateClipInObject( lpImage, NO ) )
;
ProgressEnd();
}
else
if ( wID == IDM_PASTEASNEW )
{
if ( lpFrame = AstralFrameLoad( Names.PasteImageFile, -1,
&idDataType, &idFileType) )
{
if ( NewImageWindow(
NULL, // lpOldFrame
NULL, // Name
lpFrame, // lpNewFrame
idFileType, // lpImage->FileType
idDataType, // lpImage->DataType
FALSE, // New view?
IMG_DOCUMENT, // lpImage->DocumentType
NULL, // lpImage->ImageName
MAYBE
) )
lpImage->fChanged = YES;
}
}
break;
case IDM_ESCAPE:
if (!lpImage)
break;
if (lpImage->hWnd == hZoomWindow)
break;
if ( Tool.bActive && Tool.lpToolProc )
DestroyProc( lpImage->hWnd, 1L );
break;
case IDM_SIZEUP:
case IDM_SIZEDOWN:
if (!Retouch.hBrush)
break;
SetFocus( hWindow ); // Take focus away from any controls
if ( Retouch.BrushShape == IDC_BRUSHCUSTOM )
break;
if ( wID == IDM_SIZEUP )
{
if( bHexBrush && ( Retouch.BrushSize % 2 == 0 ) && ( Retouch.BrushSize > 6 ))
Retouch.BrushSize += 2;
else
Retouch.BrushSize++;
}
else
{
if( bHexBrush && ( Retouch.BrushSize % 2 == 0 ) && ( Retouch.BrushSize > 6 ))
Retouch.BrushSize -= 2;
else
Retouch.BrushSize--;
}
if ( Retouch.BrushSize < 1 || Retouch.BrushSize > MAX_BRUSH_SIZE )
{
Retouch.BrushSize = bound( Retouch.BrushSize, 1,MAX_BRUSH_SIZE);
MessageBeep(0);
break;
}
if (lpImage)
DisplayBrush(0, 0, 0, OFF);
SetMgxBrushSize(Retouch.hBrush, Retouch.BrushSize);
if (lpImage && Window.hCursor == Window.hNullCursor)
DisplayBrush(lpImage->hWnd, 32767, 32767, ON);
if ( Tool.hRibbon )
SetSlide( Tool.hRibbon, IDC_BRUSHSIZE, Retouch.BrushSize );
break;
case IDM_SHAPEUP:
case IDM_SHAPEDOWN:
if (!Retouch.hBrush)
break;
SetFocus( hWindow ); // Take focus away from any controls
NewShape = Retouch.BrushShape;
if ( wID == IDM_SHAPEUP )
NewShape++;
else NewShape--;
if ( NewShape > IDC_BRUSHCUSTOM )
NewShape = IDC_BRUSHCIRCLE;
if ( NewShape < IDC_BRUSHCIRCLE )
NewShape = IDC_BRUSHCUSTOM;
if (lpImage)
DisplayBrush(0, 0, 0, OFF);
if (!SetMgxBrushShape(Retouch.hBrush, NewShape, Names.CustomBrush))
{
NewShape = IDC_BRUSHCIRCLE;
SetMgxBrushShape(Retouch.hBrush, NewShape, Names.CustomBrush);
}
Retouch.BrushShape = NewShape;
if (lpImage && Window.hCursor == Window.hNullCursor)
DisplayBrush(lpImage->hWnd, 32767, 32767, ON);
if ( Tool.hRibbon )
{
CheckComboItem( Tool.hRibbon, IDC_BRUSHSHAPE, IDC_BRUSHCIRCLE,
IDC_BRUSHCUSTOMNEW, Retouch.BrushShape );
SendMessage( Tool.hRibbon, WM_CONTROLENABLE, 0, 0L );
}
break;
case IDM_MOVEUP:
case IDM_MOVEDOWN:
case IDM_MOVELEFT:
case IDM_MOVERIGHT:
if (!lpImage)
break;
lpBase = ImgGetBase(lpImage);
if (ImgGetSelObject(lpImage, NULL) == lpBase)
break;
dx = dy = 0;
if (wID == IDM_MOVEUP)
--dy;
if (wID == IDM_MOVEDOWN)
++dy;
if (wID == IDM_MOVELEFT)
--dx;
if (wID == IDM_MOVERIGHT)
++dx;
lpObject = NULL;
while (lpObject = ImgGetSelObject(lpImage, lpObject))
{
rect = lpObject->rObject;
OffsetRect(&rect, dx, dy);
if (!AstralIntersectRect(&rTemp, &lpBase->rObject, &rect))
break;
}
if (lpObject)
break;
AstralSetRectEmpty(&rAll);
lpObject = NULL;
while (lpObject = ImgGetSelObject(lpImage, lpObject))
{
rect = lpObject->rObject;
OffsetRect(&lpObject->rObject, dx, dy);
AstralUnionRect(&rAll, &rAll, &lpObject->rObject);
if (!lpObject->Pixmap.fNewFrame &&
EqualRect(&rect, &lpObject->rUndoObject))
lpObject->rUndoObject = lpObject->rObject;
UpdateImage(&rect, TRUE);
UpdateImage(&lpObject->rObject, TRUE);
}
if (wID == IDM_MOVEUP)
{
x = (rAll.left + rAll.right)/2;
y = rAll.top;
}
else
if (wID == IDM_MOVEDOWN)
{
x = (rAll.left + rAll.right)/2;
y = rAll.bottom;
}
else
if (wID == IDM_MOVELEFT)
{
x = rAll.left;
y = (rAll.top + rAll.bottom)/2;
}
else
if (wID == IDM_MOVERIGHT)
{
x = rAll.right;
y = (rAll.top + rAll.bottom)/2;
}
File2Display(&x, &y);
AutoScroll(lpImage->hWnd, x, y);
AstralUpdateWindow(lpImage->hWnd);
DisplayInfo(-1, &rAll);
break;
case IDM_LASTTOOL:
DeactivateTool();
if ( Tool.idLast && (hWnd = AstralDlgGet(IDD_MAIN)) )
SendMessage( hWnd, WM_COMMAND, Tool.idLast, 2L);
break;
case IDM_PREF:
// prevent problems if running animations and they change
// the wave mix dll setting in preferences
StopAnimation();
AstralDlg( NO|2, hInstAstral, hWindow, IDD_PREF, DlgPrefProc );
break;
case IDC_VIEWLAST: // duplicate of function in the view ribbon
if ( !lpImage )
break;
RevertLastView();
break;
// case IDC_VIEWFULL: // duplicate of function in the view ribbon
// if ( !lpImage )
// break;
// AstralDlg( NO, hInstAstral, hWindow, IDD_VIEWFULL, DlgFullScreenViewProc );
// break;
case IDC_VIEWALL: // duplicate of function in the view ribbon
if ( !lpImage )
break;
ViewAll();
break;
case IDC_ZOOMIN: // duplicate of function in the view ribbon
if ( !lpImage )
break;
if (!lpImage->lpDisplay)
break;
if (!lpImage->lpDisplay->ViewPercentage)
break;
x = ( lpImage->lpDisplay->FileRect.left
+ lpImage->lpDisplay->FileRect.right ) / 2;
y = ( lpImage->lpDisplay->FileRect.top
+ lpImage->lpDisplay->FileRect.bottom ) / 2;
SaveLastView();
Zoom(x,y, +100, YES, ( View.ZoomWindow ^ CONTROL ) );
break;
case IDC_ZOOMOUT: // duplicate of function in the view ribbon
if ( !lpImage )
break;
if (!lpImage->lpDisplay)
break;
if (!lpImage->lpDisplay->ViewPercentage)
break;
x = ( lpImage->lpDisplay->FileRect.left
+ lpImage->lpDisplay->FileRect.right ) / 2;
y = ( lpImage->lpDisplay->FileRect.top
+ lpImage->lpDisplay->FileRect.bottom ) / 2;
SaveLastView();
Zoom(x,y, -100, YES,( View.ZoomWindow ^ CONTROL ) );
break;
case IDM_HELP:
Control.Hints = !Control.Hints;
PutDefInt (Control.Hints,Control.Hints);
break;
default:
return( FALSE );
}
return( TRUE );
}