mirror of
https://github.com/gnustep/libs-gui.git
synced 2025-04-25 10:31:09 +00:00
0bb2eca5a9
git-svn-id: svn+ssh://svn.gna.org/svn/gnustep/libs/gui/trunk@9741 72102866-910b-0410-8b05-ffd578937521
432 lines
9.1 KiB
Objective-C
432 lines
9.1 KiB
Objective-C
/*
|
|
Functions.m
|
|
|
|
Generic Functions for the GNUstep GUI Library.
|
|
|
|
Copyright (C) 1996,1999 Free Software Foundation, Inc.
|
|
|
|
Author: Scott Christley <scottc@net-community.com>
|
|
Date: 1996
|
|
|
|
This file is part of the GNUstep GUI Library.
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2 of the License, or (at your option) any later version.
|
|
|
|
This library 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
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public
|
|
License along with this library; see the file COPYING.LIB.
|
|
If not, write to the Free Software Foundation,
|
|
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include <Foundation/NSAutoreleasePool.h>
|
|
#include <Foundation/NSBundle.h>
|
|
#include <Foundation/NSProcessInfo.h>
|
|
|
|
#include <AppKit/NSApplication.h>
|
|
#include <AppKit/NSEvent.h>
|
|
#include <AppKit/NSGraphicsContext.h>
|
|
#include <AppKit/NSGraphics.h>
|
|
|
|
#ifdef STRICT_OPENSTEP
|
|
// This is used for the old text functions.
|
|
#include <AppKit/NSCStringText.h>
|
|
#endif
|
|
|
|
char **NSArgv = NULL;
|
|
|
|
/*
|
|
* Main initialization routine for the GNUstep GUI Library Apps
|
|
*/
|
|
int
|
|
NSApplicationMain(int argc, const char **argv)
|
|
{
|
|
NSDictionary *infoDict;
|
|
NSString *className;
|
|
Class appClass;
|
|
CREATE_AUTORELEASE_POOL(pool);
|
|
#if defined(LIB_FOUNDATION_LIBRARY) || defined(GS_PASS_ARGUMENTS)
|
|
extern char **environ;
|
|
|
|
[NSProcessInfo initializeWithArguments: (char**)argv
|
|
count: argc
|
|
environment: environ];
|
|
#endif
|
|
|
|
infoDict = [[NSBundle mainBundle] infoDictionary];
|
|
className = [infoDict objectForKey: @"NSPrincipalClass"];
|
|
appClass = NSClassFromString(className);
|
|
|
|
if (appClass == 0)
|
|
{
|
|
NSLog(@"Bad application class '%@' specified", className);
|
|
appClass = [NSApplication class];
|
|
}
|
|
|
|
[[appClass sharedApplication] run];
|
|
|
|
DESTROY(NSApp);
|
|
|
|
RELEASE(pool);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Convert an NSEvent Type to it's respective Event Mask
|
|
*/
|
|
unsigned
|
|
NSEventMaskFromType(NSEventType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case NSLeftMouseDown: return NSLeftMouseDownMask;
|
|
case NSLeftMouseUp: return NSLeftMouseUpMask;
|
|
case NSMiddleMouseDown: return NSMiddleMouseDownMask;
|
|
case NSMiddleMouseUp: return NSMiddleMouseUpMask;
|
|
case NSRightMouseDown: return NSRightMouseDownMask;
|
|
case NSRightMouseUp: return NSRightMouseUpMask;
|
|
case NSMouseMoved: return NSMouseMovedMask;
|
|
case NSMouseEntered: return NSMouseEnteredMask;
|
|
case NSMouseExited: return NSMouseExitedMask;
|
|
case NSLeftMouseDragged: return NSLeftMouseDraggedMask;
|
|
case NSMiddleMouseDragged: return NSMiddleMouseDraggedMask;
|
|
case NSRightMouseDragged: return NSRightMouseDraggedMask;
|
|
case NSKeyDown: return NSKeyDownMask;
|
|
case NSKeyUp: return NSKeyUpMask;
|
|
case NSFlagsChanged: return NSFlagsChangedMask;
|
|
case NSPeriodic: return NSPeriodicMask;
|
|
case NSCursorUpdate: return NSCursorUpdateMask;
|
|
case NSAppKitDefined: return NSAppKitDefinedMask;
|
|
case NSSystemDefined: return NSSystemDefinedMask;
|
|
case NSApplicationDefined: return NSApplicationDefinedMask;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Color Functions
|
|
*/
|
|
|
|
/*
|
|
* Get Information About Color Space and Window Depth
|
|
*/
|
|
const NSWindowDepth*
|
|
NSAvailableWindowDepths(void)
|
|
{
|
|
/*
|
|
* Perhaps this is the only function which
|
|
* belongs in the backend. It should be possible
|
|
* to detect which depths the window server is capable
|
|
* of.
|
|
*/
|
|
return (const NSWindowDepth *)_GSWindowDepths;
|
|
}
|
|
|
|
NSWindowDepth
|
|
NSBestDepth(NSString *colorSpace, int bitsPerSample, int bitsPerPixel,
|
|
BOOL planar, BOOL *exactMatch)
|
|
{
|
|
int components = NSNumberOfColorComponents(colorSpace);
|
|
int index = 0;
|
|
const NSWindowDepth *depths = NSAvailableWindowDepths();
|
|
NSWindowDepth bestDepth = NSDefaultDepth;
|
|
|
|
*exactMatch = NO;
|
|
|
|
if (components == 1)
|
|
{
|
|
for (index = 0; depths[index] != 0; index++)
|
|
{
|
|
NSWindowDepth depth = depths[index];
|
|
|
|
if (NSPlanarFromDepth(depth))
|
|
{
|
|
bestDepth = depth;
|
|
if (NSBitsPerSampleFromDepth(depth) == bitsPerSample)
|
|
{
|
|
*exactMatch = YES;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (index = 0; depths[index] != 0; index++)
|
|
{
|
|
NSWindowDepth depth = depths[index];
|
|
|
|
if (!NSPlanarFromDepth(depth))
|
|
{
|
|
bestDepth = depth;
|
|
if (NSBitsPerSampleFromDepth(depth) == bitsPerSample)
|
|
{
|
|
*exactMatch = YES;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return bestDepth;
|
|
}
|
|
|
|
int
|
|
NSBitsPerPixelFromDepth(NSWindowDepth depth)
|
|
{
|
|
int bps = NSBitsPerSampleFromDepth(depth);
|
|
int spp = 0;
|
|
|
|
if (depth & _GSRGBBitValue)
|
|
{
|
|
spp = 3;
|
|
}
|
|
else if (depth & _GSCMYKBitValue)
|
|
{
|
|
spp = 4;
|
|
}
|
|
else if (depth & _GSGrayBitValue)
|
|
{
|
|
spp = 1;
|
|
}
|
|
return (spp * bps);
|
|
}
|
|
|
|
int
|
|
NSBitsPerSampleFromDepth(NSWindowDepth depth)
|
|
{
|
|
NSWindowDepth bitValue = 0;
|
|
|
|
/*
|
|
* Test against colorspace bit.
|
|
* and out the bit to get the bps value.
|
|
*/
|
|
if (depth & _GSRGBBitValue)
|
|
{
|
|
bitValue = _GSRGBBitValue;
|
|
}
|
|
else if (depth & _GSCMYKBitValue)
|
|
{
|
|
bitValue = _GSCMYKBitValue;
|
|
}
|
|
else if (depth & _GSGrayBitValue)
|
|
{
|
|
bitValue = _GSGrayBitValue;
|
|
}
|
|
/*
|
|
* AND against the complement
|
|
* to extract the bps value.
|
|
*/
|
|
return (depth & ~(bitValue));
|
|
}
|
|
|
|
NSString*
|
|
NSColorSpaceFromDepth(NSWindowDepth depth)
|
|
{
|
|
NSString *colorSpace = NSCalibratedWhiteColorSpace;
|
|
|
|
/*
|
|
* Test against each of the possible colorspace bits
|
|
* and return the corresponding colorspace.
|
|
*/
|
|
if (depth == 0)
|
|
{
|
|
colorSpace = NSCalibratedBlackColorSpace;
|
|
}
|
|
else if (depth & _GSRGBBitValue)
|
|
{
|
|
colorSpace = NSCalibratedRGBColorSpace;
|
|
}
|
|
else if (depth & _GSCMYKBitValue)
|
|
{
|
|
colorSpace = NSDeviceCMYKColorSpace;
|
|
}
|
|
else if (depth & _GSGrayBitValue)
|
|
{
|
|
colorSpace = NSCalibratedWhiteColorSpace;
|
|
}
|
|
else if (depth & _GSNamedBitValue)
|
|
{
|
|
colorSpace = NSNamedColorSpace;
|
|
}
|
|
else if (depth & _GSCustomBitValue)
|
|
{
|
|
colorSpace = NSCustomColorSpace;
|
|
}
|
|
|
|
return colorSpace;
|
|
}
|
|
|
|
int
|
|
NSNumberOfColorComponents(NSString *colorSpaceName)
|
|
{
|
|
int components = 1;
|
|
|
|
/*
|
|
* These are the only exceptions to the above.
|
|
* All other colorspaces have as many bps as bpp.
|
|
*/
|
|
if ([colorSpaceName isEqualToString: NSCalibratedRGBColorSpace]
|
|
|| [colorSpaceName isEqualToString: NSDeviceRGBColorSpace])
|
|
{
|
|
components = 3;
|
|
}
|
|
else if ([colorSpaceName isEqualToString: NSDeviceCMYKColorSpace])
|
|
{
|
|
components = 4;
|
|
}
|
|
return components;
|
|
}
|
|
|
|
BOOL
|
|
NSPlanarFromDepth(NSWindowDepth depth)
|
|
{
|
|
BOOL planar = NO;
|
|
|
|
/*
|
|
* Only the grayscale depths are planar.
|
|
* All others are interleaved.
|
|
*/
|
|
if (depth & _GSGrayBitValue)
|
|
{
|
|
planar = YES;
|
|
}
|
|
return planar;
|
|
}
|
|
|
|
|
|
#ifdef STRICT_OPENSTEP
|
|
//
|
|
// Old Text Functions, this come from a very old version of the
|
|
// OpenStep specification and will probably never be implemented in GNUstep
|
|
//
|
|
|
|
//
|
|
// Filter Characters Entered into a Text Object
|
|
//
|
|
unsigned short
|
|
NSEditorFilter(unsigned short theChar,
|
|
int flags, NSStringEncoding theEncoding)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
unsigned short
|
|
NSFieldFilter(unsigned short theChar,
|
|
int flags, NSStringEncoding theEncoding)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Calculate or Draw a Line of Text (in Text Object)
|
|
//
|
|
int
|
|
NSDrawALine(id self, NSLayInfo *layInfo)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
NSScanALine(id self, NSLayInfo *layInfo)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Calculate Font Ascender, Descender, and Line Height (in Text Object)
|
|
//
|
|
void
|
|
NSTextFontInfo(id fid, float *ascender, float *descender, float *lineHeight)
|
|
{}
|
|
|
|
//
|
|
// Access Text Object's Word Tables
|
|
//
|
|
NSData*
|
|
NSDataWithWordTable(const unsigned char *smartLeft,
|
|
const unsigned char *smartRight,
|
|
const unsigned char *charClasses,
|
|
const NSFSM *wrapBreaks,
|
|
int wrapBreaksCount,
|
|
const NSFSM *clickBreaks,
|
|
int clickBreaksCount,
|
|
BOOL charWrap)
|
|
{
|
|
return nil;
|
|
}
|
|
|
|
void
|
|
NSReadWordTable(NSZone *zone,
|
|
NSData *data,
|
|
unsigned char **smartLeft,
|
|
unsigned char **smartRight,
|
|
unsigned char **charClasses,
|
|
NSFSM **wrapBreaks,
|
|
int *wrapBreaksCount,
|
|
NSFSM **clickBreaks,
|
|
int *clickBreaksCount,
|
|
BOOL *charWrap)
|
|
{}
|
|
|
|
//
|
|
// Array Allocation Functions for use by the old NSText Class
|
|
//
|
|
|
|
NSTextChunk*
|
|
NSChunkCopy(NSTextChunk *pc, NSTextChunk *dpc)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
NSTextChunk*
|
|
NSChunkGrow(NSTextChunk *pc, int newUsed)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
NSTextChunk*
|
|
NSChunkMalloc(int growBy, int initUsed)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
NSTextChunk*
|
|
NSChunkRealloc(NSTextChunk *pc)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
NSTextChunk*
|
|
NSChunkZoneCopy(NSTextChunk *pc,
|
|
NSTextChunk *dpc,
|
|
NSZone *zone)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
NSTextChunk*
|
|
NSChunkZoneGrow(NSTextChunk *pc, int newUsed, NSZone *zone)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
NSTextChunk*
|
|
NSChunkZoneMalloc(int growBy, int initUsed, NSZone *zone)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
NSTextChunk*
|
|
NSChunkZoneRealloc(NSTextChunk *pc, NSZone *zone)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
#endif
|