WebSVN – filter_foundry – Diff – /trunk/telegraphics_common/tt/dlg.c

 /*
         This file is part of a common library
     Copyright (C) 1990-2006 Toby Thain, toby@telegraphics.com.au
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 #include "carbonstuff.h"
 #include <quickdraw.h>
 #include <controls.h>
 #include <dialogs.h>
 #include <events.h>
 #include <osutils.h> // Delay
 #include <palettes.h> // GetGray
 #include <resources.h>
 #include <textutils.h> // NumToString
 #include <ctype.h>
 #include <gestalt.h>
 #include "dlg.h"
 #include "qd.h"
 #include "wind.h"
 #include "misc-mac.h"
 #if 0 //TARGET_API_MAC_CARBON /* FIXME:KLUDGE */
 #define DisposeRoutineDescriptor
 #define NewRoutineDescriptor( theProc, theProcInfo, theISA) (theProc)
 #define NewDeviceLoopDrawingProc
 #endif
 pascal void grey_item_dldp(short depth, short deviceFlags, GDHandle targetDevice, long userData);
 DialogPtr get_centred_dialog(short id){ DialogRef d;
         // assume the dialog is initially invisible; otherwise the centring process would be ugly
         /*centre_window*/(d = GetNewDialog(id,0,(WindowPtr)-1));
         ShowWindow(GetDialogWindow(d));
         return d;
 }
 void centre_alert(short id){
         AlertTHndl a = (AlertTHndl)GetResource('ALRT',id);
         centre_rect(&(*a)->boundsRect);
 }
 Point centred(short id){ DialogTHndl t; Rect s;
         t = (DialogTHndl)GetResource('DLOG',id);
         s = (*t)->boundsRect;
         ReleaseResource((Handle)t);
         centre_rect(&s);
         return TOPLEFT(s);
 }
 /* dialog utilities */
 Handle item_handle(DialogPtr d,short i){
         short kind;
         Handle item;
         Rect box;
         GetDialogItem(d,i,&kind,&item,&box);
         return item;
 }
 void get_item_rect(DialogPtr d,short i,Rect*r){
         short kind;
         Handle item;
         GetDialogItem(d,i,&kind,&item,r);
 }
 void inval_item(DialogPtr d,short i){
         Rect r;
         //GrafPtr gp;
         get_item_rect(d,i,&r);
         //GetPort(&gp);         SetPort(d);
         InvalWindowRect(GetDialogWindow(d),&r);
         //SetPort(gp);
 }
 void hide_items(DialogPtr d,long v){ int i;
         for(i=1;v>>=1;i++)
                 if(v&1)
                         HideDialogItem(d,i);
 }
 void show_items(DialogPtr d,long v){ int i;
         for(i=1;v>>=1;i++)
                 if(v&1)
                         ShowDialogItem(d,i);
 }
 void set_user_item(DialogPtr d,short i,UserItemUPP p){
         short kind;
         Handle item;
         Rect box;
         GetDialogItem(d,i,&kind,&item,&box);
         SetDialogItem(d,i,kind,(void*)p,&box);
 }
 void set_item_value(DialogPtr d,short i,short v){
         SetControlValue((ControlHandle)item_handle(d,i),v);
 }
 void get_item_text(DialogPtr d,short i,Str255 s){
         GetDialogItemText(item_handle(d,i),s);
 }
 void set_item_text(DialogPtr d,short i,Str255 s){
         SetDialogItemText(item_handle(d,i),s);
 }
 void set_num_item(DialogPtr d,short i,long n){
         Str255 s;
         NumToString(n,s);
         SetDialogItemText(item_handle(d,i),s);
 }
 long get_num_item(DialogPtr d,short i){
         Str255 s;
         long n;
         GetDialogItemText(item_handle(d,i),s);
         StringToNum(s,&n);
         return n;
 }
 USER_ITEM(dimmed_item){ PenState ps; Rect r; Pattern pat;
         get_item_rect(theDialog,itemNo,&r);
         GetPenState(&ps);
         GetQDGlobalsGray(&pat);
         PenPat(&pat);
         PenMode(patBic);
         PaintRect(&r);
         SetPenState(&ps);
 }
 #if 0
 USER_ITEM(grey_item){ PenState ps; Rect r;
         get_item_rect(theDialog,itemNo,&r);
         GetPenState(&ps);
         PenPat(&SAFE_QD(gray));
         FrameRect(&r);
         SetPenState(&ps);
 }
 #else
 pascal void grey_item_dldp(short depth, short deviceFlags, GDHandle targetDevice, long userData){
         RGBColor save,fg,bg;
         PenState ps;
         int f;
         Pattern pat;
         GetBackColor(&bg);
         GetForeColor(&fg);
         save = fg;
         if( f = GetGray(targetDevice, &bg, &fg) ){
                 RGBForeColor(&fg);
         }else{
                 GetPenState(&ps);
                 GetQDGlobalsGray(&pat);
                 PenPat(&pat);
         }
         FrameRect((Rect*)userData);
         f ? RGBForeColor(&save) : SetPenState(&ps);
 }
 USER_ITEM(grey_item){
         Rect r;
         RgnHandle rgn;
         DeviceLoopDrawingUPP proc = NewDeviceLoopDrawingUPP(grey_item_dldp);
         GrafPtr gp;
         GetPort(&gp);
         SetPort((GrafPtr)GetWindowPort(GetDialogWindow(theDialog)));
         get_item_rect(theDialog,itemNo,&r);
         RectRgn(rgn = NewRgn(),&r);
         DeviceLoop(rgn, proc, (long)&r, 0);
         DisposeRgn(rgn);
         SetPort(gp);
         DisposeDeviceLoopDrawingUPP(proc);
 }
 #endif
 USER_ITEM(framed_item){ Rect r;
         get_item_rect(theDialog,itemNo,&r);
         FrameRect(&r);
 }
 USER_ITEM(label_frame_item){ Rect r; RgnHandle rgn,rgn2;
         // draws a single-pixel frame around the item,
         // leaving out the rectangle of the previous item
         // (which is usually the label for the frame)
         GetClip(rgn = NewRgn());
         get_item_rect(theDialog,itemNo-1,&r);
         RectRgn(rgn2 = NewRgn(),&r);
         DiffRgn(rgn,rgn2,rgn2);
         SetClip(rgn2);
         grey_item(theDialog, itemNo);
         SetClip(rgn);
         DisposeRgn(rgn);
         DisposeRgn(rgn2);
 }
 USER_ITEM(outlined_item){ PenState ps; Rect r; int k; Pattern pat;
         get_item_rect(theDialog,itemNo,&r);
         GetPenState(&ps);
         PenSize(3,3);
         if( GetControlHilite( (ControlHandle)item_handle(theDialog,GetDialogDefaultItem(theDialog)) ) ){
                 GetQDGlobalsGray(&pat);
                 PenPat(&pat);
         }
         k = (r.bottom-r.top)/2 + 2; // ???
         FrameRoundRect(&r,k,k);
         SetPenState(&ps);
 }
 #if 0
 // determine what character a keypress would be had it not been modified by the command key
 // this code is absolutely useless
 char unmodified_key(EventRecord*e){ short keycode; long state=0,c; char c1; void *transData;
         if(transData = (void*)GetEnvirons(smKCHRCache)){
                 keycode = (e->modifiers & (0xff00 & ~cmdKey)) | ((e->message & keyCodeMask) >> 8);
                 c = KeyTrans(transData,keycode,&state);
                 return (c1 = c>>16) ? c1 : c;
         }else
                 return e->message;
 }
 /*
 You're wrong Phil. Command does in fact disable the shift modifier. See
 the tech note on International Cancelling. To properly handle the command
 key in your application, you should always strip the command-key bit out
 of the modifiers field and re-pass the keystroke through KeyTrans. Here's
 some source code for doing it with the cancel key, but you should use
 similar code for any command-key combination (like in MenuKey):
 */
 /* These both use Universal Headers. The second is for System 6 too. */
 Boolean WasCancel(EventRecord *theEvent)
 {
     short keyCode;
     long state = 0L, test;
     unsigned long keys;
     if(!(theEvent->modifiers & cmdKey))
         return(false);
     keyCode = (theEvent->modifiers & 0xFE00) |
               ((theEvent->message & keyCodeMask) >> 8);
     keys = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache),
                         keyCode, &state);
     return(((Byte)keys == '.') || ((Byte)(keys >>= 16) == '.'));
 }
 Boolean WasCancelSystem6or7(EventRecord *theEvent)
 {
     short keyCode, rsrcID, scriptID;
     Ptr kchrPtr;
     Handle kchrRsrc = nil;
     long state = 0L;
     unsigned long keys;
     if(!(theEvent->modifiers & cmdKey))
         return(false);
     keyCode = (theEvent->modifiers & 0xFE00) |
               ((theEvent->message & keyCodeMask) >> 8);
     if((kchrPtr = (Ptr)GetScriptManagerVariable(smKCHRCache)) == nil) {
         scriptID = GetScriptManagerVariable(smKeyScript);
         rsrcID = GetScriptVariable(scriptID, smScriptKeys);
         kchrRsrc = GetResource('KCHR', rsrcID);
         if(kchrRsrc != nil)
             kchrPtr = *kchrRsrc;
     }
     if(kchrPtr != nil)
         keys = KeyTranslate(kchrPtr, keyCode, &state);
     if(kchrRsrc != nil)
         ReleaseResource(kchrRsrc);
     return(((Byte)keys == '.') || ((Byte)(keys >>= 16) == '.'));
 }
 // Pete Resnick    (...so what is a mojo, and why would one be rising?)
 #endif
 Boolean is_a_button(DialogPtr d,int i){ KIND_ITEM_BOX
         GetDialogItem(d,i,&kind,&item,&box);
         return kind==ctrlItem|btnCtrl && !GetControlHilite((ControlHandle)item);
 }
 // TO DO: modify is_cancel to use IsCmdChar (scripts.h)
 Boolean is_cancel(EventRecord*e){ char c = e->message;
         return e->what==keyDown && ((e->modifiers&cmdKey && c=='.') || c==27);
 }
 FILTER(filter_buttons){ int i=0,j; char c; Str255 s; WindowPtr w; Boolean f = false;
         switch(theEvent->what){
         case mouseDown:
                 if(theEvent->modifiers & cmdKey && FindWindow(theEvent->where,&w) == inDrag){
                         BitMap bm;
                         GetQDGlobalsScreenBits(&bm);
                         DragWindow(w,theEvent->where,&bm.bounds);
                         theEvent->what = nullEvent;
                 }
                 break;
         case keyDown:
                 c = theEvent->message;
                 if( (c==3 || c==13) && is_a_button(theDialog,GetDialogDefaultItem(theDialog)) )
                         i = GetDialogDefaultItem(theDialog);
                 else if(is_cancel(theEvent) && is_a_button(theDialog,cancel))
                         i = cancel;
                 else if(GetDialogKeyboardFocusItem(theDialog) == -1 /*|| theEvent->modifiers & cmdKey*/
                                 && gestalt_attr(gestaltDITLExtAttr,gestaltDITLExtPresent)){
                         c = tolower(c);
                         for(j=CountDITL(theDialog);j;j--){ KIND_ITEM_BOX
                                 GetDialogItem(theDialog,j,&kind,&item,&box);
                                 if( (kind&(itemDisable|ctrlItem))==ctrlItem && !GetControlHilite((ControlHandle)item) ){
                                         GetControlTitle((ControlHandle)item,s);
                                         if(*s && tolower(s[1])==c)
                                                 if(i){ // two buttons' titles begin with the same character
                                                         i = 0;
                                                         break;
                                                 }else
                                                         i = j;
                                 }
                         }
                 }
                 if(i){
                         flash_button(theDialog,*itemHit = i);
                         f = true;
                 }
         }
         return f;
 }
 /*      It would be nice to highlight the button until the user releases the key,
         but if the key was released before the event mask is set to include key-up events,
         the event won't be posted, and the button stays highlighted until a key is next released.
         The easy solution is to enable key-up events when the application starts up;
         however, I'm not sure that the extra code to do this
                 *(short*)SysEvtMask |= keyUpMask
         and wait for the event
                 while(!EventAvail(keyUpMask,&e)) ;
         is justified.
         (There's also the overhead of an extra event per keypress.)
         We should only un-highlight the button if the SAME key was released as was pressed.
 */
 void flash_button(DialogPtr d,short i){
 #if 0 // I'm temporarily taking this code out, because "inButton" has disappeared from headers???
         ControlHandle c; unsigned long t; int h;
         c = (ControlHandle)item_handle(d,i);
         h = (*c)->contrlHilite;
         HiliteControl(c,inButton);
         Delay(8,&t);
         HiliteControl(c,h);
 #endif
 }

Subversion Repositories filter_foundry

filter_foundry/trunk/telegraphics_common/tt/dlg.c – Rev 193 → 259