コード例 #1
0
ファイル: RLDisplayMachO.cpp プロジェクト: mctully/tntbasic
//	Make a new ScreenRef that corresponds to the rectangle indicated by the where parameter
ScreenRef	NewScreenRef( const Rect *where, OSStatus *error )
{
	RLDisplay *display = NULL;

	// MakeNewRLDisplay may throw exceptions so we have to catch them here so 
	// that we dont inflict them on our C loving public!
	try
	{
		display = MakeNewRLDisplay( where );
		
		// In the particular case of operator new failing, we just get a NULL 
		// pointer back, so generate the exception ourselves.
		if( ! display )
		{
			DEBUGMESSAGE( "Screen Ref allocation failed -- not enough memory!" );
			throw OSStatus( rlOutOfMemory );
		}

		if( error )
			*error = noErr;
	}
	catch( OSStatus err )
	{
		if( error )
			*error = err;	
	}

	return ScreenRef( display );
}
コード例 #2
0
ファイル: RLDisplayMachO.cpp プロジェクト: mctully/tntbasic
OSStatus	FadeToGamma( ScreenRef screen, const RLGammaTable *newGamma, float seconds )
{
	if( ! newGamma )
		return paramErr;

	DEBUGMESSAGE( "Fading to new gamma over " << seconds << " seconds." );

	//Calculate the starting and ending time for out fade
	double startTime = GetCurrentTime();
	double endTime = startTime + seconds;
	
	//Determine our starting gamma
	RLGammaTable	oldGamma, currentGamma;
	OSStatus error = GetGamma( screen, &oldGamma );
	if( error )
		return error;

	//Loop until we run out of time, resetting the gamma as fast as possible
	for( double currentTime = GetCurrentTime(); currentTime < endTime && ! error; currentTime = GetCurrentTime() )
	{
		//The fraction is the percentage of time that we have spend so far in this loop as a value between 0 and 1.0
		double fraction = (currentTime - startTime) / seconds;	
		
		//Calculate the new gamma based on the amount of time spent so far
		//(1-fraction)startGamma + fraction * endGamma = startGamma + fraction( endGamma - startGamma)
		for( int i = 0; i < kGammaTableEntryCount; i++ )
		{
			currentGamma.red[i] = oldGamma.red[i] + fraction * (newGamma->red[i] - oldGamma.red[i]);
			currentGamma.green[i] = oldGamma.green[i] + fraction * (newGamma->green[i] - oldGamma.green[i]);
			currentGamma.blue[i] = oldGamma.blue[i] + fraction * (newGamma->blue[i] - oldGamma.blue[i]);		
		}
		
		error = SetGamma( screen, &currentGamma );
	}
	
	if( error )
		DEBUGMESSAGE( "Got error # " << error << " doing a gamma fade in FadeToGamma(). Attempting to achieve the final gamma...." );
		
	return SetGamma( screen, newGamma );
}
コード例 #3
0
ファイル: RLDisplayMachO.cpp プロジェクト: mctully/tntbasic
// MT : this is a compatibility routine to do stuff that used to be done in the cfm initialiser of rezlib
static Handle LoadDITL()
{
	//Load the dialog item list for our AskIfNewResolutionWorks() function dialog box
	static Handle		s_ditl=NULL;
	if (!s_ditl)
	{
		//Load our DITL
		s_ditl = Get1Resource( 'DITL', 27398 );
		if( s_ditl )
		{
			DEBUGMESSAGE( "\"AskIfNewResolutionWorks\" DITL loaded." );
			DetachResource( s_ditl );
		}
		else
			DEBUGMESSAGE( "Error: Failed to load DITL." );
		
		OSStatus err = ResError();
		CHECKERR( err );
		if( err )
			DEBUGMESSAGE( "Found Resource Manager error # " << err << " after attempting to load the \"AskIfNewResolutionWorks\" DITL. " );	
	}
	return s_ditl;
}
コード例 #4
0
ファイル: RLDisplayMachO.cpp プロジェクト: mctully/tntbasic
//Dispose of a retrace callback installed using InstallVerticalRetraceProcedure().
void		DisposeVerticalRetraceProcedure( RetraceToken token )
{
	RetraceProc *proc = (RetraceProc*) token;
	if( NULL == proc )
		return;
	
	RLDisplay	*owner = proc->GetOwner();
	if( NULL == owner )
	{
		DEBUGMESSAGE("Error: detected a retrace procedure without an owner!" );
		return;
	}	
	
	owner->DisposeVerticalRetraceProcedure( proc );
}
コード例 #5
0
ファイル: RLDisplayMachO.cpp プロジェクト: mctully/tntbasic
// Poll the display for its current resolution, color depth and other settings
OSStatus		GetCurrentSetting( ScreenRef screen, RLInfo *info )
{
	RLDisplay *display = (RLDisplay *) screen;
	
	if( ! display )
		return rlInvalidScreenRef;
	
	if( NULL == info )
		return paramErr;
	
	if( info->rlInfoType != 0 )
	{
		DEBUGMESSAGE("Be sure to set the RLInfo.rlInfoType field to zero before calling GetCurrentSetting()!" );
		return paramErr;
	}
			
	return display->GetCurrentScreenSetting( info );	
}
コード例 #6
0
static BOOL CALLBACK AboutDlgProc(
                                    HWND hDlg,
                                    UINT message,
                                    WPARAM wParam,
                                    LPARAM lParam
                                    )
{
    //DEBUGMESSAGE(("AboutDlgProc"));

    switch (message)
    {
    case WM_INITDIALOG:
        {
            DEBUGMESSAGE(("AboutDlgProc - WM_INITDIALOG"));
            LPPROPSHEETPAGE page = (LPPROPSHEETPAGE ) lParam;
    
            // attach to our property sheet page an instance of our data holder class
            CHyperLink *hyperLink = new CHyperLink();
            SetWindowLongPtr(hDlg, DWL_USER, (LONG) hyperLink);

            // transform the static text into an hyperlink!
            // it couldn't be easier - many thanks to Olivier Langlois
            hyperLink->ConvertStaticToHyperlink(
                        hDlg, IDC_PROJECT_URL,
                        TEXT("http://emfprinter.sourceforge.net"));

            // set about text
            TCHAR txt[256];
            StringCchPrintf(txt, 256, 
                TEXT("This is EmfPrinter %d.%d.%d by Francesco Montorsi (c) 2007.\n")
                TEXT("Licensed under the terms of the GNU General Public License."),
                emfVERSION_MAJOR, emfVERSION_MINOR, emfVERSION_RELEASE);
            HWND hwnd = GetDlgItem(hDlg, IDC_ABOUT_TEXT);
            SendMessage(hwnd, WM_SETTEXT, 0, (LPARAM)txt);
        } 
        break;

    default:
        //DEBUGMESSAGE(("AboutDlgProc - unhandled message %d", message));
        return FALSE;
    }

    return TRUE;
}
コード例 #7
0
// DrvDocumentPropertySheets function is responsible for creating property 
// sheet pages that describe a print document's properties.
LONG DrvDocumentPropertySheets(
                               PPROPSHEETUI_INFO pPSUIInfo,
                               LPARAM            lParam
                               )
{
    //DEBUGMESSAGE(("DrvDocumentPropertySheets"));

    LONG lRetValue = -1;

    if (pPSUIInfo == NULL)
        return DirectDrvDocumentPropertySheets((PDOCUMENTPROPERTYHEADER) lParam);
    else if (pPSUIInfo->lParamInit != 0)
        return IndirectDrvDocumentPropertySheets(pPSUIInfo,
                    (PDOCUMENTPROPERTYHEADER)pPSUIInfo->lParamInit,
                    lParam);
    else
        DEBUGMESSAGE(("Received a NULL PDOCUMENTPROPERTYHEADER"));

    return lRetValue;
}
コード例 #8
0
ファイル: pvs.c プロジェクト: jff/mathspad
int pvs_parse(unsigned char *buffer, unsigned int *len)
{
  char *pos, *lastpos;
  unsigned int reslen;
  reslen=0;
  buffer[*len]=0;
  lastpos=(char*)buffer;
  DEBUGMESSAGE(buffer);
  pos = strstr((char*)buffer, PVSPREFIX);
  while (pos) {
    char *t;
    int i;
    int savereslen;
    DEBUGMESSAGE(pos);
    /* copy plain content */
    savereslen=reslen;
    if (pvs_after_init) {
      while (lastpos<pos) {
	buffer[reslen++] = *lastpos++;
      }
    }
    if (pvs_in_checker) {
      unsigned char cv;
      int nres;
      nres = reslen-savereslen;
      if (nres) {
	cv = buffer[reslen];
	buffer[reslen]=0;
	pvs_parse_prove(buffer+savereslen, &nres);
	buffer[reslen]=cv;
	reslen=savereslen+nres;
      }
    }
    i=0;
    while (pvsmessage[i].keyval &&
	   strncmp(pos+PVSPREFLEN,pvsmessage[i].keyval,pvsmessage[i].keylen))
      i++;
    if (!pvsmessage[i].keyval) {
      /* unknown pvs message */
      char *b;
      i++;
      b=pos+PVSPREFLEN;
      while (*b!=' ') b++;
      *b=0;
      strcpy(pvsmessage[i].keyval,pos+PVSPREFLEN);
      pvsmessage[i].keylen = strlen(pos+PVSPREFLEN);
      sprintf(pvsmessage[i].endstr, PVSENDPREF "%s\n", pos+PVSPREFLEN);
      pvsmessage[i].endlen = strlen(pvsmessage[i].endstr);
    }
    t=strstr(pos, pvsmessage[i].endstr);
    if (t) {
      *t=0;
      (*pvsmessage[i].func)(pos+PVSPREFLEN+pvsmessage[i].keylen);
      t=t+pvsmessage[i].endlen;
    } else {
      int k;
      parsemess=i;
      k=strlen(pos);
      if (k) {
	if (stilllen<k) {
	  if (stilltoparse)
	    stilltoparse = realloc(stilltoparse, (k+1)*sizeof(char));
	  else
	    stilltoparse = malloc((k+1)*sizeof(char));
	  stilllen=k;
	}
	strcpy(stilltoparse, pos);
	t=pos+k;
      }
    }
    lastpos=t;
    pos=strstr(lastpos,PVSPREFIX);
  }
  {
    int savereslen;
    savereslen=reslen;
    if (pvs_after_init) {
      while (*lastpos) {
	buffer[reslen++]=*lastpos++;
      }
    }
    buffer[reslen]=0;
    DEBUGMESSAGE(buffer);
    if (strstr(buffer, "(Yes or No)")) {
      edit_string_to_proces(translate("no\n"), translate("PVS-shell"));
    }
    if (pvs_before_realtime &&
	strstr(buffer, "Real time =")) {
      pvs_before_realtime=0;
      pvs_start_proof(NULL);
    }      
    if (pvs_in_checker) {
      int nres;
      nres = reslen-savereslen;
      if (nres) {
	pvs_parse_prove(buffer,&nres);
	reslen=savereslen+nres;
      }
    }
    DEBUGMESSAGE(buffer);
  }
  message(MP_MESSAGE,busylist[currentbusy]);
  currentbusy=(currentbusy+1)%4;
  *len=reslen;
  return (reslen==0);
}
コード例 #9
0
// DrvDeviceCapabilities function returns requested information
// about a printer's capabilities.
//
// NOTE:
//   WE NEED TO TAKE INTO ACCOUNT DIFFERENCE BETWEEN OUR CAPS, TARGET CAPS
DWORD DrvDeviceCapabilities(
                            HANDLE    hPrinter,
                            PWSTR     pDeviceName,
                            WORD      iDevCap,
                            VOID      *pvOutput,
                            PDEVMODE  pDevMode
	                        )
{
    //DEBUGMESSAGE(("DrvDeviceCapabilities"));

	DWORD dwRetValue = GDI_ERROR;
    WORD *pwOutput = (WORD*)pvOutput;
    POINTS *pptsdwRet = ((POINTS *)&dwRetValue);

    switch (iDevCap)
    {
    case DC_PAPERNAMES:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_PAPERNAMES"));
    case DC_MEDIAREADY:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_MEDIAREADY"));
        if (pvOutput) {
            TCHAR str[] = TEXT("None (the printer is virtual!)");
            // each paper name is 64 chars max
            strCopy((LPTSTR)pvOutput, str, strBufferSize(str));
        }
        return 1;

    case DC_PAPERS:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_PAPERS"));
        if (pvOutput)
            *pwOutput = DMPAPER_A4;     // A4 is 210x297 mm
        return 1;

    case DC_PAPERSIZE:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_PAPERSIZE"));
        if (pvOutput) {
            POINT *arr = (POINT*)pvOutput;
            arr[0].x = A4_WIDTH_MM*10;
            arr[0].y = A4_HEIGHT_MM*10;
        }
        return 1;

    case DC_BINNAMES:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_BINNAMES"));
        if (pvOutput)
            // each bin name is 24 chars max
            strCopy((LPTSTR)pvOutput, TEXT("Bin"), 3*sizeof(TCHAR));
        return 1;

    case DC_BINS:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_BINS"));
        if (pvOutput)
            *pwOutput = DMBIN_ONLYONE;
        return 1;

    case DC_COPIES:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_COPIES"));
        return 1;

    case DC_STAPLE:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_STAPLE"));
        return 0;   // not supported
    case DC_COLLATE:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_COLLATE"));
        return 0;   // not supported
    case DC_DUPLEX:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_DUPLEX"));
        return 0;   // not supported

    case DC_ENUMRESOLUTIONS:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_ENUMRESOLUTIONS"));
        if (pvOutput) {
            LONG *arr = (LONG*)pvOutput;
            arr[0] = emfDRIVER_WIDTH_DPI;
            arr[1] = emfDRIVER_HEIGHT_DPI;
        }
        return 1;

        // info about our driver's devmode

    case DC_DRIVER:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_DRIVER"));
        return emfDRIVER_REAL_VERSION;
    case DC_EXTRA:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_EXTRA"));
        return extdmSizeofPrivate();
    case DC_SIZE:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_SIZE"));
        return sizeof(DEVMODEW);    // size of only public members
    case DC_VERSION:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_VERSION"));
        return DM_SPECVERSION;
    case DC_FIELDS:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_FIELDS"));
        return extdmDEFAULT_FIELDS;
    case DC_FILEDEPENDENCIES:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_FILEDEPENDENCIES"));
        return 0;

    case DC_MAXEXTENT:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_MAXEXTENT"));
        pptsdwRet->x = A4_WIDTH_MM*10;
        pptsdwRet->y = A4_HEIGHT_MM*10;
        return dwRetValue;

    case DC_MINEXTENT:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_MINEXTENT"));
        // min is 1 mm
        pptsdwRet->x = 10;
        pptsdwRet->y = 10;
        return dwRetValue;

    case DC_ORIENTATION:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_ORIENTATION"));
        return 90;


    case DC_TRUETYPE:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_TRUETYPE"));
        return DCTT_BITMAP;//|DCTT_SUBDEV|DCTT_DOWNLOAD;

    case DC_PERSONALITY:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_PERSONALITY"));
        if (pvOutput)
            // each printer desc lang name is 32 chars max
            strCopy((LPTSTR)pvOutput, TEXT("EMF"), 3*sizeof(TCHAR));
        return 1;

    case DC_COLORDEVICE:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_COLORDEVICE"));
        return 1;

    //case DC_SPL_MEDIAREADY:

    case DC_NUP:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_NUP"));
        return 1;

    case DC_PRINTERMEM:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_PRINTERMEM"));
        return 4096;        // simulate 4MB of internal mem

        // 60 pages per minute: we're fast :)
    case DC_PRINTRATE:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_PRINTRATE"));
    case DC_PRINTRATEPPM:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_PRINTRATEPPM"));
        return 60;
    case DC_PRINTRATEUNIT:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_PRINTRATEUNIT"));
        return PRINTRATEUNIT_PPM;

    case DC_BINADJUST:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_BINADJUST"));
        // should be not used for WinXP/2000 but I've tested
        // that MS Word calls WinXP drivers with this code too!
        return DCBA_FACEUPNONE;

    case DC_EMF_COMPLIANT:
        DEBUGMESSAGE(("DrvDeviceCapabilities - DC_EMF_COMPLIANT"));
        // should be not used for WinXP/2000 but just to be sure...
        return 1;

        // other win98 only codes:
    //case DC_DATATYPE_PRODUCED:
    //case DC_MANUFACTURER:
    //case DC_MODEL:

    default:
        DEBUGMESSAGE(("Unexpected device capability required: %d", iDevCap));
        return GDI_ERROR;
    }

	return dwRetValue;
}
コード例 #10
0
static BOOL CALLBACK DocPropDlgProc(
                                    HWND hDlg,
                                    UINT message,
                                    WPARAM wParam,
                                    LPARAM lParam
                                    )
{
    //DEBUGMESSAGE(("DocPropDlgProc"));

    switch (message)
    {
    case WM_INITDIALOG:
        {
            DEBUGMESSAGE(("DocPropDlgProc - WM_INITDIALOG"));
            LPPROPSHEETPAGE page = (LPPROPSHEETPAGE) lParam;

            // attach to our property sheet page an instance of our data holder class
            DocumentPropDialogData *data = (DocumentPropDialogData *) page->lParam;
            SetWindowLongPtr(hDlg, DWL_USER, (LONG) data);

            // fill output format combos
            HWND hwndVectorFormats = GetDlgItem(hDlg, IDC_COMBO_VECTOR_FORMAT);
            FillComboWithOutputFormats(hwndVectorFormats, g_vectorFormats, 
                                       ARRCOUNT(g_vectorFormats));
            HWND hwndRasterFormats = GetDlgItem(hDlg, IDC_COMBO_RASTER_FORMAT);
            FillComboWithOutputFormats(hwndRasterFormats, g_rasterFormats,
                                       ARRCOUNT(g_rasterFormats));

            // select the right format
            SelectFormat(hDlg, extdmGetOutputFormat(data->m_pExtdmCurrent));

            // set default text control contents
            SendMessage(GetDlgItem(hDlg, IDC_OUTPUT_FOLDER), 
                        WM_SETTEXT, 0, (LPARAM)extdmGetOutputFolder(data->m_pExtdmCurrent));
            SendMessage(GetDlgItem(hDlg, IDC_OUTPUT_FILENAME), 
                        WM_SETTEXT, 0, (LPARAM)extdmGetOutputFilename(data->m_pExtdmCurrent));           SendMessage(GetDlgItem(hDlg, IDC_IMAGEMAGICK_OPTIONS), 
                        WM_SETTEXT, 0, (LPARAM)extdmGetConvertOptions(data->m_pExtdmCurrent));           SendMessage(GetDlgItem(hDlg, IDC_POSTGEN_CMD), 
                        WM_SETTEXT, 0, (LPARAM)extdmGetPostGenCmd(data->m_pExtdmCurrent));

            // check override box eventually
            CheckDlgButton(hDlg, IDC_OVERRIDE_CHECKBOX, 
                extdmAllowUserOverride(data->m_pExtdmCurrent) ? BST_CHECKED : BST_UNCHECKED);

            CheckDlgButton(hDlg, IDC_CROP_CHECKBOX, 
                extdmCropBorders(data->m_pExtdmCurrent) ? BST_CHECKED : BST_UNCHECKED);

            CheckDlgButton(hDlg, IDC_OPEN_VIEWER_CHECKBOX, 
                extdmViewOutputFile(data->m_pExtdmCurrent) ? BST_CHECKED : BST_UNCHECKED);
        } 
        break; // case WM_INITDIALOG

    case WM_COMMAND:
        return OnCommand(hDlg, LOWORD(wParam), HIWORD(wParam));

    case WM_NOTIFY:
        return OnNotify(hDlg, (LPNMHDR)lParam);

    default:
        //DEBUGMESSAGE(("DocPropDlgProc - unhandled message %d", message));
        return FALSE;
    }

    return TRUE;
}
コード例 #11
0
BOOL OnCommand(HWND hDlg, WORD wID, WORD code)
{
    //DEBUGMESSAGE(("OnCommand"));

    DocumentPropDialogData *data = 
        (DocumentPropDialogData *) GetWindowLongPtr(hDlg, DWL_USER);

    switch (wID)
    {
    case IDC_COMBO_VECTOR_FORMAT:
    case IDC_COMBO_RASTER_FORMAT:
        {
            DEBUGMESSAGE(("OnCommand - combo command"));
            switch (code)
            {
            case CBN_SELCHANGE:
                {
                    DWORD nId = 
                        (wID==IDC_COMBO_VECTOR_FORMAT) ? 
                            IDC_VECTOR_FORMAT_RADIOBOX : 
                            IDC_RASTER_FORMAT_RADIOBOX;

                    // select the radio button next to the combo which changed
                    CheckRadioButton(hDlg, 
                             IDC_VECTOR_FORMAT_RADIOBOX, IDC_RASTER_FORMAT_RADIOBOX,
                             nId);
                }
                break;

            default:
                break;
            }
        }
        break;

    case IDC_BROWSE_BUTTON:
        {
            BROWSEINFO bi;
            bi.hwndOwner      = hDlg;
            bi.pidlRoot       = NULL;
            bi.pszDisplayName = NULL;
            bi.lpszTitle      = TEXT("Choose output folder");
            bi.ulFlags        = BIF_RETURNONLYFSDIRS | BIF_STATUSTEXT;
            bi.lpfn           = BrowseCallbackProc;

            LPTSTR folder = NULL;
            if (!GetEditControlText(&folder, GetDlgItem(hDlg, IDC_OUTPUT_FOLDER))) {
                DEBUGMESSAGE(("DocPropDlgProc - could not get output folder text"));
                return FALSE;
            }

            bi.lParam         = (LPARAM)folder; // param for the callback

            const int verComCtl32 = GetComCtl32Version();

            // we always add the edit box (it doesn't hurt anybody, does it?) if it is
            // supported by the system
            if ( verComCtl32 >= 471 )
            {
                bi.ulFlags |= BIF_EDITBOX;
            }

            // to have the "New Folder" button we must use the "new" dialog style which
            // is also the only way to have a resizable dialog
            if (verComCtl32 >= 500)
            {
                bi.ulFlags |= BIF_NEWDIALOGSTYLE;
            }

            // do show the dialog
            wxItemIdList pidl(SHBrowseForFolder(&bi));

            // cleanup
            wxItemIdList::Free((LPITEMIDLIST)bi.pidlRoot);
            strFree((LPTSTR)bi.lParam);

            if ( !pidl )
            {
                DEBUGMESSAGE(("user hit cancel"));
                return TRUE;
            }

            LPTSTR newPath = pidl.GetPath();
            if (newPath)
            {
                // change the text in the associated control
                SendMessage(GetDlgItem(hDlg, IDC_OUTPUT_FOLDER), 
                            WM_SETTEXT, 0, (LPARAM)newPath);
                strFree(newPath);
            }
        }
        break;

    default:
        break;
    }

    return FALSE;
}
コード例 #12
0
BOOL OnNotify(HWND hDlg, LPNMHDR lpNMHdr)
{
    //DEBUGMESSAGE(("OnNotify"));

    UINT uiCode = lpNMHdr->code;
    switch (uiCode)
    {
    case PSN_APPLY:
        {
            DEBUGMESSAGE(("OnNotify - PSN_APPLY"));

            DocumentPropDialogData *data = 
                (DocumentPropDialogData *) GetWindowLongPtr(hDlg, DWL_USER);
            if (data == NULL) {
                DEBUGMESSAGE(("DocPropDlgProc - invalid internal data pointer"));
                return FALSE;
            }

            // which format combo should we use?
            LPTSTR format = NULL;
            if (IsDlgButtonChecked(hDlg, IDC_VECTOR_FORMAT_RADIOBOX) == BST_CHECKED)
            {
                INT sel = GetComboCurSel(GetDlgItem(hDlg, IDC_COMBO_VECTOR_FORMAT));
                format = strDuplicate(g_vectorFormats[sel].strName);
            }
            else if (IsDlgButtonChecked(hDlg, IDC_RASTER_FORMAT_RADIOBOX) == BST_CHECKED)
            {
                INT sel = GetComboCurSel(GetDlgItem(hDlg, IDC_COMBO_RASTER_FORMAT));
                format = strDuplicate(g_rasterFormats[sel].strName);
            }
            else
            {
                DEBUGMESSAGE(("DocPropDlgProc - unexpected condition"));
                return FALSE;
            }

            // get the output folder & validate it
            LPTSTR folder = NULL;
            if (!GetEditControlText(&folder, GetDlgItem(hDlg, IDC_OUTPUT_FOLDER))) {
                DEBUGMESSAGE(("DocPropDlgProc - could not get output folder text"));
                return FALSE;
            }
            if (!FolderExists(folder)) {
                ErrorMessage(hDlg, TEXT("Warning"),
                       TEXT("The given output directory does not exist!"));
                return FALSE;
            }

            // get the output filename & validate it
            LPTSTR filename = NULL;
            if (!GetEditControlText(&filename, GetDlgItem(hDlg, IDC_OUTPUT_FILENAME))) {
                DEBUGMESSAGE(("DocPropDlgProc - could not get output filename text"));
                return FALSE;
            }
            if (!IsValidFilename(filename)) {
                LPTSTR temp = strCat(TEXT("The given output filename is not valid!\n"),
                                     TEXT("It should not contain any of the '"),
                                     g_strFileNameForbiddenChars,
                                     TEXT("' characters."),
                                     NULL);
                ErrorMessage(hDlg, TEXT("Warning"), temp);
                strFree(temp);
                return FALSE;
            }

            // get the raster conv options
            LPTSTR rasteropt = NULL;
            if (!GetEditControlText(&rasteropt, GetDlgItem(hDlg, IDC_IMAGEMAGICK_OPTIONS))) {
                DEBUGMESSAGE(("DocPropDlgProc - could not get raster conv opt text"));
                return FALSE;
            }

            // get the postgen cmd
            LPTSTR postgen = NULL;
            if (!GetEditControlText(&postgen, GetDlgItem(hDlg, IDC_POSTGEN_CMD))) {
                DEBUGMESSAGE(("DocPropDlgProc - could not get postgen cmd text"));
                return FALSE;
            }

            // get override checkbox status
            BOOL override = 
                IsDlgButtonChecked(hDlg, IDC_OVERRIDE_CHECKBOX) == BST_CHECKED;

            // get crop checkbox
            BOOL crop = 
                IsDlgButtonChecked(hDlg, IDC_CROP_CHECKBOX) == BST_CHECKED;

            // get open-output checkbox
            BOOL openout = 
                IsDlgButtonChecked(hDlg, IDC_OPEN_VIEWER_CHECKBOX) == BST_CHECKED;

            // save all data in the EXTDEVMODE
            extdmSetPrivateData(data->m_pExtdmCurrent, 
                                format, filename, folder, rasteropt, postgen, 
                                override, openout, crop);

            // cleanup
            strFree(format);  
            strFree(filename);  
            strFree(folder);
            strFree(postgen);
            strFree(rasteropt);

            // call the _SET_RESULT callback
            PFNCOMPROPSHEET pfnComPropSheet = data->m_pfnComPropSheet;
            LONG lTemp = pfnComPropSheet(
                                        data->m_hComPropSheet, 
                                        CPSFUNC_SET_RESULT,
                                        (LPARAM) data->m_hPropSheetAdded,
                                        CPSUI_OK
                                        );

            return TRUE;
        }
        break;

    case PSN_RESET:
        break;

    case PSN_SETACTIVE:
        break;

    default:
        break;
    }

    return FALSE;
}
コード例 #13
0
LONG IndirectDrvDocumentPropertySheets(PPROPSHEETUI_INFO pPSUIInfo,
                                       PDOCUMENTPROPERTYHEADER pdph,
                                       LPARAM lParam)
{
    //DEBUGMESSAGE(("IndirectDrvDocumentPropertySheets - indirect call by the UI"));

    DWORD fMode = pdph->fMode;
    ASSERT(pdph != NULL && pPSUIInfo != NULL);

    if (fMode & DM_ADVANCED)
    {
        // MSDN say:
        // If set, the DrvDocumentPropertySheets function should only 
        // create the Advanced document page.
        // If not set, the DrvDocumentPropertySheets function should 
        // create both the Page Setup and Advanced document pages.
    }

    // WE ARE BEING CALLED BY CPSUI, TO SHOW TO THE USER 
    // THE CONFIGURABLE PROPERTY SHEETS FOR THIS DOCUMENT

    switch (pPSUIInfo->Reason)
    {
    case PROPSHEETUI_REASON_INIT:
        { 
            DEBUGMESSAGE(("IndirectDrvDocumentPropertySheets - initializing the sheet"));

            // alloc data
            DocumentPropDialogData *data = new DocumentPropDialogData();
            LPPROPSHEETPAGE page = (LPPROPSHEETPAGE) malloc(sizeof(PROPSHEETPAGE));

            if (data == NULL || page == NULL) {
                DEBUGMESSAGE(("OUT OF MEMORY"));
                return -1;   // failure
            }

            // initialize a page of the document property dialog
            ZeroMemory(page, sizeof(*page));
            page->dwSize = sizeof(*page);
            page->hInstance = g_hInstDLL;
            page->pszTemplate = MAKEINTRESOURCE(IDD_DIALOG_DOCUMENTPROPERTIES);
            page->lParam = (LPARAM) data;
            page->pfnDlgProc = (DLGPROC) DocPropDlgProc;

            // from pm
            //page->dwFlags = PSP_USECALLBACK;
            //psp->pfnCallback = PropSheetPageProc;
     
            // save some stuff in the provided pointer
            pPSUIInfo->UserData = (ULONG_PTR) page;
            pPSUIInfo->Result   = CPSUI_CANCEL;


            // fill DocumentPropDialogData structure
            // -------------------------------------

            data->m_bAllowUserUpdate =
                (pdph->fMode & DM_OUT_BUFFER)  &&
                !(pdph->fMode & DM_NOPERMISSION) &&
                pdph->pdmOut != NULL;

            // set the initial devmode for this dialog
            if ((pdph->fMode & DM_IN_BUFFER) &&
                pdph->pdmIn != NULL &&
                extdmIsAnExtDevMode(pdph->pdmIn))
                dmCopy((LPBYTE)data->m_pExtdmCurrent, pdph->pdmIn);
            else
                extdmSetToDefault(data->m_pExtdmCurrent);

            data->m_pfnComPropSheet = pPSUIInfo->pfnComPropSheet;
            data->m_hComPropSheet = pPSUIInfo->hComPropSheet;

            // this call will actually create the sheet
            data->m_hPropSheetAdded = 
                (HANDLE) pPSUIInfo->pfnComPropSheet(
                                                    pPSUIInfo->hComPropSheet,
                                                    CPSFUNC_ADD_PROPSHEETPAGE,
                                                    (LPARAM)page, 
                                                    0
                                                    );

            if (data->m_hPropSheetAdded == NULL)
            {
                DEBUGMESSAGE(("COULD NOT CREATE THE PROPERTY SHEET PAGE"));
                delete data;
                if (page != NULL)
                    free(page);
                return -1;
            }

            // create the about sheet
            {
                LPPROPSHEETPAGE page = (LPPROPSHEETPAGE) malloc(sizeof(PROPSHEETPAGE));

                if (data == NULL || page == NULL) {
                    DEBUGMESSAGE(("OUT OF MEMORY"));
                    return -1;   // failure
                }

                // initialize a page of the document property dialog
                ZeroMemory(page, sizeof(*page));
                page->dwSize = sizeof(*page);
                page->hInstance = g_hInstDLL;
                page->pszTemplate = MAKEINTRESOURCE(IDD_DIALOG_ABOUT);
                page->lParam = (LPARAM) data;
                page->pfnDlgProc = (DLGPROC) AboutDlgProc;

                // ignore error code - it's not fundamental
                (HANDLE) pPSUIInfo->pfnComPropSheet(
                                                    pPSUIInfo->hComPropSheet,
                                                    CPSFUNC_ADD_PROPSHEETPAGE,
                                                    (LPARAM)page, 
                                                    0
                                                    );
            }

            return 1;   // success
        }
        break;

    case PROPSHEETUI_REASON_SET_RESULT:
        {
            DEBUGMESSAGE(("IndirectDrvDocumentPropertySheets - saving the result"));

            LPPROPSHEETPAGE page = (LPPROPSHEETPAGE) pPSUIInfo->UserData;
            PSETRESULT_INFO psri = (PSETRESULT_INFO) lParam;
            if (psri->Result != CPSUI_OK)
                return 1;

            if (page == NULL) {
                DEBUGMESSAGE(("Unexpected NULL ptr"));
                return -1;
            }

            DocumentPropDialogData* data = 
                (DocumentPropDialogData *) page->lParam;
            if (data->m_bAllowUserUpdate)
            {
                // save the user-edited options in the given out PDEVMODE
                dmCopy((LPBYTE)pdph->pdmOut, (PCDEVMODE)data->m_pExtdmCurrent);
            }

            return 1;
        }
        break;

    case PROPSHEETUI_REASON_DESTROY:
        {
            DEBUGMESSAGE(("IndirectDrvDocumentPropertySheets - destroying the sheet"));

            LPPROPSHEETPAGE page = (LPPROPSHEETPAGE) pPSUIInfo->UserData;
            if (page == NULL) {
                DEBUGMESSAGE(("Unexpected NULL ptr"));
                return -1;
            }

            DocumentPropDialogData *data = (DocumentPropDialogData *) page->lParam;
            if (data != NULL)
                delete data;     // we won't need it anymore
            else
                DEBUGMESSAGE(("Unexpected NULL ptr"));

            free(page);
            pPSUIInfo->UserData = 0;

            return 1;
        } 
        break;

    default:
        break;
    }

    DEBUGMESSAGE(("IndirectDrvDocumentPropertySheets - unhandled reason %d", 
                 pPSUIInfo->Reason));

    return -1;  // unhandled reason...
}
コード例 #14
0
LONG DirectDrvDocumentPropertySheets(PDOCUMENTPROPERTYHEADER pdph)
{
    //DEBUGMESSAGE(("DirectDrvDocumentPropertySheets - direct call by the spooler"));

    // CALLED DIRECTLY BY SPOOLER, RATHER THAN INDIRECTLY THROUGH CPSUI

    DWORD fMode = pdph->fMode;
    ASSERT(pdph != NULL);

    if (fMode == 0 || pdph->pdmOut == NULL)
    {
        DEBUGMESSAGE(("DirectDrvDocumentPropertySheets - "
                      "I was asked for EXTDEVMODE size (which is %d bytes)", 
                      extdmSizeof()));

        pdph->cbOut = (LONG) extdmSizeof();
        return pdph->cbOut;
    } 

    PDEVMODE pdmIn = pdph->pdmIn;
    PDEVMODE pdmOut = pdph->pdmOut;

    if (pdmIn && (fMode & DM_IN_BUFFER) &&
        pdmIn->dmSize == sizeof(DEVMODEW) && 
        pdmIn->dmDriverExtra == extdmSizeofPrivate())
    {
        // MSDN says:
        // The caller has supplied a DEVMODE structure pointer 
        // in pdmIn, and the DrvDocumentPropertySheets function 
        // should update its internal DEVMODE structure to reflect 
        // the contents of the supplied DEVMODE.

        DEBUGMESSAGE(("DirectDrvDocumentPropertySheets - I was asked to "
                      "update my internal DEVMODE from pdmIn"));

        // nothing to update actually
        return 1;   // success
    }

    if (pdmOut && (fMode & DM_OUT_BUFFER))
    {
        // MSDN says:
        // The caller has supplied a DEVMODE structure pointer in 
        // pdmOut, and the DrvDocumentPropertySheets function 
        // should copy the contents of its internal DEVMODE structure 
        // into the supplied DEVMODE.

        DEBUGMESSAGE(("DirectDrvDocumentPropertySheets - I was asked to "
                      "update pdmOut from my internal DEVMODE"));

        // create our internal devmode
        PEXTDEVMODE pExt = (PEXTDEVMODE)pdmOut;
        extdmSetToDefault(pExt);

        // get the devmode for current printer
        PDEVMODE pdmTemp = GetPrinterDevMode(pdph->pszPrinterName);
        if (pdmTemp != NULL) {
            extdmMerge(pExt, pdmTemp);
            free(pdmTemp);
        } 

        // copy our "internal" devmode in the output devmode
        dmCopy((LPBYTE) pdmOut, (PDEVMODE) pExt);

        return 1;   // success
    }

    if ((fMode & DM_ADVANCED) || (fMode & DM_IN_PROMPT))
    {
        // we were asked to create document property sheets in a
        // direct spooler call - this shouldn't happen!

        DEBUGMESSAGE(("DirectDrvDocumentPropertySheets - I was asked to create "
                      "sheets in a direct call - WARNING THIS SHOULDN'T HAPPEN"));

        return -1;
    }

    if ((fMode & DM_USER_DEFAULT) || (fMode & DM_OUT_DEFAULT))
    {
        DEBUGMESSAGE(("DirectDrvDocumentPropertySheets - DM_USER_DEFAULT and "
                      "DM_OUT_DEFAULT should not be used!"));

        return -1;
    }

    DEBUGMESSAGE(("DirectDrvDocumentPropertySheets - unhandled call with "
                  "fMode == %d, pdmIn == %d, pdmOut == %d", fMode, pdmIn, pdmOut));

    return -1;
}
コード例 #15
0
ファイル: RLDisplayMachO.cpp プロジェクト: mctully/tntbasic
/* Do a gamma fade to the gamma table provided over the time period desired	*/
OSStatus		FadeToGammaMultiple( ScreenRef *screen, unsigned int count, const RLGammaTable *newGamma, float seconds )
{
	int i;
	OSStatus error = noErr;

	if( ! newGamma )
		return paramErr;

	//Calculate the starting and ending time for out fade
	double startTime = GetCurrentTime();
	double endTime = startTime + seconds;
	
	//Determine our starting gamma
	RLGammaTable	*oldGamma = (RLGammaTable*) NewPtr( sizeof( RLGammaTable ) * count );
	RLGammaTable	*currentGamma = (RLGammaTable*) NewPtr( sizeof( RLGammaTable ) * count );
	
	if( NULL == oldGamma || NULL == currentGamma )
	{
		if( NULL != oldGamma )
			DisposePtr( Ptr( oldGamma ) );
		if( NULL != currentGamma )
			DisposePtr( Ptr( currentGamma ) );	
	
		return rlOutOfMemory;
	}
		
	for( i = 0; i < count; i++ )
	{
		error = GetGamma( screen[i], &oldGamma[i] );
		if( noErr != error )
			goto exit;
	}
	

	//Loop until we run out of time, resetting the gamma as fast as possible
	for( double currentTime = GetCurrentTime(); currentTime < endTime; currentTime = GetCurrentTime() )
	{
		//The fraction is the percentage of time that we have spend so far in this loop as a value between 0 and 1.0
		double fraction = (currentTime - startTime) / seconds;	
		
		for( i = 0; i < count; i++ )
		{
			
			//Calculate the new gamma based on the amount of time spent so far
			//(1-fraction)startGamma + fraction * endGamma = startGamma + fraction( endGamma - startGamma)
			for( int j = 0; j < kGammaTableEntryCount; j++ )
			{
				currentGamma[i].red[j] = oldGamma[i].red[j] + fraction * (newGamma[i].red[j] - oldGamma[i].red[j]);
				currentGamma[i].green[j] = oldGamma[i].green[j] + fraction * (newGamma[i].green[j] - oldGamma[i].green[j]);
				currentGamma[i].blue[j] = oldGamma[i].blue[j] + fraction * (newGamma[i].blue[j] - oldGamma[i].blue[j]);		
			}
			
			error = SetGamma( screen[i], &currentGamma[i] );
	
			if( noErr != error )
				goto finish;
		}

	}

finish:	
	if( error )
		DEBUGMESSAGE( "Got error # " << error << " doing a gamma fade in FadeToGamma(). Attempting to achieve the final gamma...." );
		
	for( i = 0; i < count; i++ )
		 SetGamma( screen[i], &newGamma[i] );

exit:
	DisposePtr( Ptr( oldGamma ) );
	DisposePtr( Ptr( currentGamma ) );

	return error;
}
コード例 #16
0
ファイル: RLDisplayMachO.cpp プロジェクト: mctully/tntbasic
//
//	AskIfNewResolutionWorks() creates a dialog box in the center of the screen. The dialog asks the 
//	user if the current display setting works. This is necessary because a number of display settings
//	listed by the OS dont actually work and leave the user with a black screen.  The dialog has a 5
//	second timeout. If the user does not hit ok within 5 seconds the cancel item is chosen automatically
//	for him. This feature allows the user to do nothing (which he will probably do if confronted by a 
//	black screen) and still be ok.  The method that I have employed to do the timeout requires Appearances
//	1.1. I believe this was introduced with OS 8.5. If you want to support back to OS 8.1, then you will
//	have to do your own modal dialog event proc that implements a timeout. The dialog has not default 
//	button by default. Cmd-period and esc trigger the cancel button.
//
//
OSStatus		AskIfNewResolutionWorks( ScreenRef screen )
{
	DEBUGMESSAGE( "Querying user whether the new resolution works...." );

	if( ! screen )
		return noErr;

	//Read the new screen dimensions
	RLDrawInfo 	screenData;
	Rect		dialogBounds = {0,0,130, 340};
	OSStatus 		error = GetCurrentScreenDrawingInfo( screen, &screenData );
	if( error )
	{
		DEBUGMESSAGE( "Unable to get current screen drawing information. Got back error # " << error );
		return error;
	}
	
	//Make a copy of our dialog item list. This will be destroyed when the dialog is destroyed.
	Handle ditlCopy = LoadDITL();
	HandToHand( &ditlCopy );
	
	//Center the dialog rect on the screen
	{
		SInt32 horizontalOffset = (SInt32( screenData.bounds.right) + SInt32( screenData.bounds.left ) - SInt32(dialogBounds.right) +  SInt32(dialogBounds.left) ) / 2;
		SInt32 verticalOffset = (SInt32( screenData.bounds.bottom) + SInt32( screenData.bounds.top ) - SInt32(dialogBounds.bottom) +  SInt32(dialogBounds.top) ) / 2;
		dialogBounds.left += horizontalOffset;
		dialogBounds.right += horizontalOffset;
		dialogBounds.top += verticalOffset;
		dialogBounds.bottom += verticalOffset;
	}
		
	//Init a new dialog hidden
	DialogPtr dialog =  NewFeaturesDialog( NULL, &dialogBounds, "\pResolution Verification", true, kWindowModalDialogProc,
									(WindowPtr) -1L, false, TickCount(), ditlCopy, 0 );
	if( ! dialog )
	{
		DEBUGMESSAGE( "Unable to init the \"AskIfNewResolutionWorks\" dialog window. Perhaps there is insufficient free memory or the DITL did not load properly at library startup?" );
		return rlOutOfMemory;
	}
	
	//Make sure the dialog cancel item is button # 2	
	SetDialogCancelItem( dialog, 2 );

	//Set dialog to timeout after 5 seconds	
	SetDialogTimeout( dialog, 2, 5 );

	for( bool done = false; !done; )
	{
		short itemHit = 0;
		ModalDialog ( NULL, &itemHit );  

		switch( itemHit )
		{
			case 2:	//cancel
				DEBUGMESSAGE( "The user hit cancel or the dialog timed out. The new resolution is probably not good." );
				done = true;
				error = rlRezNotFound;
				break;

			case 3:	//ok
				DEBUGMESSAGE( "The user hit ok. The new resolution seems to be Okay!" );
				done = true;
				error = noErr;
				break;		
		}	
	}
	
	DisposeDialog( dialog );
	
	return error;
}