Làm cách nào để đặt kích thước phông chữ trong ô văn bản sao cho chuỗi lấp đầy nội dung của ô?

Question

Tôi có chế độ xem có chứa hai số NSTextFieldCell s. Kích thước mà tại đó các ô này được rút ra có nguồn gốc từ kích thước của khung nhìn và tôi muốn văn bản trong mỗi ô là lớn nhất sẽ phù hợp với kích thước có nguồn gốc của ô. Dưới đây là những gì tôi có, không đặt kích thước phông chữ:

- (void)drawRect:(NSRect)dirtyRect { 
    /* 
    * Observant readers will notice that I update the whole view here. If 
    * there is a perceived performance problem, then I'll switch to just 
    * updating the dirty rect. 
    */ 
    NSRect boundsRect = self.bounds; 
    const CGFloat monthHeight = 0.25 * boundsRect.size.height; 
    NSRect monthRect = NSMakeRect(boundsRect.origin.x, 
            boundsRect.origin.y + boundsRect.size.height 
            - monthHeight, 
            boundsRect.size.width, 
            monthHeight); 
    [monthCell drawWithFrame: monthRect inView: self]; 

    NSRect dayRect = NSMakeRect(boundsRect.origin.x, 
           boundsRect.origin.y, 
           boundsRect.size.width, 
           boundsRect.size.height - monthHeight); 
    [dayCell drawWithFrame: dayRect inView: self]; 

    [[NSColor blackColor] set]; 
    [NSBezierPath strokeRect: boundsRect]; 
} 

Vì vậy, tôi biết rằng tôi có thể yêu cầu kích thước cho thuộc tính cho trước và tôi biết rằng tôi có thể yêu cầu kiểm soát thay đổi kích thước của nó để phù hợp với nội dung của nó. Không ai trong số những người có vẻ áp dụng: Tôi muốn nội dung (trong trường hợp này, các tế bào của stringValue) để kích thước để phù hợp với kích thước rect được biết đến, với các thuộc tính cần thiết để đạt được điều đó là không rõ. Làm thế nào tôi có thể tìm thấy kích thước cần thiết? Giả sử rằng tôi biết tôi sẽ sử dụng phông chữ nào (vì tôi làm).

cập nhật Lưu ý: Tôi không muốn truncate chuỗi, tôi muốn phát triển hoặc teo nó để toàn bộ điều phù hợp với kích thước văn bản lớn nhất có thể, vào rect cung cấp .

Answer 1

tôi sử dụng một số mã tương tự nhưng nó xử lý phông chữ khác nhau, kích thước lên đến 10.000 và có tính đến chiều cao có sẵn cũng như chiều rộng của khu vực văn bản được hiển thị trong.

#define kMaxFontSize 10000 

- (CGFloat)fontSizeForAreaSize:(NSSize)areaSize withString:(NSString *)stringToSize usingFont:(NSString *)fontName; 
{ 
    NSFont * displayFont = nil; 
    NSSize stringSize = NSZeroSize; 
    NSMutableDictionary * fontAttributes = [[NSMutableDictionary alloc] init]; 

    if (areaSize.width == 0.0 || areaSize.height == 0.0) { 
     return 0.0; 
    } 

    NSUInteger fontLoop = 0; 
    for (fontLoop = 1; fontLoop <= kMaxFontSize; fontLoop++) { 
     displayFont = [[NSFontManager sharedFontManager] convertWeight:YES ofFont:[NSFont fontWithName:fontName size:fontLoop]]; 
     [fontAttributes setObject:displayFont forKey:NSFontAttributeName]; 
     stringSize = [stringToSize sizeWithAttributes:fontAttributes]; 

     if (stringSize.width > areaSize.width) 
      break; 
     if (stringSize.height > areaSize.height) 
      break; 
    } 

    [fontAttributes release], fontAttributes = nil; 

    return (CGFloat)fontLoop - 1.0; 
} 

Answer 2

Hai ý tưởng. Một Tôi đã cố gắng, người kia có thể làm việc:

1) Làm như thế nào trong câu hỏi này: How to truncate an NSString based on the graphical width? tức là chỉ cần thử kích cỡ khác nhau cho đến khi nó không phù hợp nữa

2) Tạo tế bào, cho nó tối đa rect và thiết lập nó để phù hợp với văn bản của nó vào tế bào, sau đó yêu cầu nó cho kích thước lý tưởng của nó (có một phương pháp trên đó mà làm điều đó) sau đó thay đổi kích thước các tế bào một lần nữa. Cuối cùng nếu tôi hiểu vấn đề của bạn một cách chính xác.

Answer 3

Chúng tôi khuyên bạn không nên sử dụng tìm kiếm nhị phân cho kích thước phù hợp. Đây là một ví dụ rất hạn chế về rằng:

- (NSFont *)labelFontForText: (NSString *)text inRect: (NSRect)rect { 
    CGFloat prevSize = 0.0, guessSize = 16.0, tempSize; 
    NSFont *guessFont = nil; 
    while (fabs(guessSize - prevSize) > 0.125) { 
     guessFont = [NSFont labelFontOfSize: guessSize]; 
     NSSize textSize = [text sizeWithAttributes: 
          [NSDictionary dictionaryWithObject: guessFont 
                 forKey: NSFontAttributeName]]; 
     if (textSize.width > rect.size.width || 
      textSize.height > rect.size.height) { 
      tempSize = guessSize - (guessSize - prevSize)/2.0; 
     } 
     else { 
      tempSize = guessSize + (guessSize - prevSize)/2.0; 
     } 
     prevSize = guessSize; 
     guessSize = tempSize; 
    } 
    return [[guessFont retain] autorelease]; 
} 

Những hạn chế (bạn nên không cần một 32pt hoặc phông chữ lớn hơn, hoặc bất cứ điều gì đó không phải là Lucida Grande) là không quan trọng đối với nhu cầu của tôi, nhưng chắc chắn sẽ đưa một số người ra bằng cách sử dụng phương pháp này. Tôi sẽ để câu hỏi mở ra, và chấp nhận một cách tiếp cận mạnh mẽ hơn.

Answer 4

Dưới đây là một phương pháp không đoán và kiểm tra. Tùy thuộc vào phông chữ, một chút đệm có thể là cần thiết để ngăn chặn tràn (sizeWithAttributes không quy mô hoàn hảo). Boom!

-(float)scaleToAspectFit:(CGSize)source into:(CGSize)into padding:(float)padding 
{ 
    return MIN((into.width-padding)/source.width, (into.height-padding)/source.height); 
} 

-(NSFont*)fontSizedForAreaSize:(NSSize)size withString:(NSString*)string usingFont:(NSFont*)font; 
{ 
    NSFont* sampleFont = [NSFont fontWithDescriptor:font.fontDescriptor size:12.];//use standard size to prevent error accrual 
    CGSize sampleSize = [string sizeWithAttributes:[NSDictionary dictionaryWithObjectsAndKeys:sampleFont, NSFontAttributeName, nil]]; 
    float scale = [self scaleToAspectFit:sampleSize into:size padding:10]; 
    return [NSFont fontWithDescriptor:font.fontDescriptor size:scale * sampleFont.pointSize]; 
} 

Answer 5

Trong trường hợp của tôi, tôi sử dụng như sau:

- (void)drawInteriorWithFrame:(NSRect)cellFrame inView:(NSView *)controlView 
{ 

    //Create attributes 
    NSColor *text_color = nil; 
    NSFont *font = [self font]; 
    NSString *fontName = [font fontName]; 
    double fontSize = [font pointSize]; 

    NSInteger text_size = (int) fontSize; 

    if([self isHighlighted]) 
     text_color = [NSColor colorWithCalibratedRed:1 green:1 blue:1 alpha:1]; 
    else 
     text_color = [NSColor colorWithCalibratedRed:0 green:0 blue:0 alpha:1]; 


    NSDictionary *attributes = [NSDictionary dictionaryWithObjectsAndKeys: 
           [NSFont fontWithName:fontName size:fontSize], NSFontAttributeName, 
           text_color, NSForegroundColorAttributeName, 
           nil]; 


    NSAttributedString * currentText=[[NSAttributedString alloc] initWithString:[self title] attributes: attributes]; 

    NSSize attrSize = [currentText size]; 

    while (attrSize.width > cellFrame.size.width && --text_size > 0) { 


     attributes = [NSDictionary dictionaryWithObjectsAndKeys: 
         [NSFont fontWithName:fontName size:text_size], NSFontAttributeName, 
         text_color, NSForegroundColorAttributeName, 
         nil]; 

     currentText=[[NSAttributedString alloc] initWithString:[self title] attributes: attributes]; 

     attrSize = [currentText size]; 

    } 

    switch ([self alignment]) { 
     default: 
     case NSLeftTextAlignment: 
      [currentText drawAtPoint:NSMakePoint(cellFrame.origin.x, 
               cellFrame.origin.y + (cellFrame.size.height/2) - (attrSize.height/2))]; 
      break; 

     case NSRightTextAlignment: 
      [currentText drawAtPoint:NSMakePoint(cellFrame.origin.x + (cellFrame.size.width) - (attrSize.width), 
               cellFrame.origin.y + (cellFrame.size.height/2) - (attrSize.height/2))]; 
      break; 

     case NSCenterTextAlignment: 
      [currentText drawAtPoint:NSMakePoint(cellFrame.origin.x + (cellFrame.size.width /2) - (attrSize.width/2), 
               cellFrame.origin.y + (cellFrame.size.height/2) - (attrSize.height/2))]; 
      break; 


    } 




} 

Answer 6

Xin lỗi: nó được năm năm. Chiều rộng văn bản có thể không còn là mối quan tâm hàng đầu trong cuộc sống của bạn. Tuy nhiên, tôi có câu trả lời; có thể những người khác sẽ được hưởng lợi.

Chìa khóa quan trọng để định kích thước văn bản chính xác (và công trình này cũng cho chiều cao văn bản) là nhận ra rằng chiều rộng của văn bản hiển thị không khác nhau - nhưng tuyến tính! - với cài đặt thuộc tính kích thước phông chữ. Không cần tìm kiếm nhị phân, hoặc để chọn và kiểm tra tất cả các giá trị thuộc tính có kích thước phông chữ có thể, khi có một hàm tuyến tính; người ta chỉ cần chắc chắn hai điểm trên biểu đồ.

Để chuẩn bị, không vẽ chuỗi, nhưng tính chiều rộng của chuỗi được hiển thị của bạn tại, ví dụ: cỡ chữ 20 và cỡ chữ 40. Điều này cung cấp cho bạn hai điểm dữ liệu trên hàm tuyến tính. như một hàm của thuộc tính kích thước văn bản ". Sau đó, ngoại suy để phù hợp với chuỗi thành bất kỳ chiều rộng được hiển thị nào bạn hiện đang cần.

Tôi đã tìm thấy phương pháp này để mang lại kết quả tốt và nhanh chóng thống nhất. Với các biến thể trong phông chữ, tất nhiên, đôi khi bạn có thể có được các ký tự treo hai hoặc ba pixel trên cạnh của hộp giới hạn - nhưng đây là một vật phẩm của thiết kế phông chữ. Các phông chữ được thiết kế tốt sẽ hoạt động tốt và thậm chí với phông chữ điên, phông chữ thường chỉ cung cấp đường biên của một vài pixel.

Dưới đây là các thói quen tôi đã sử dụng khi gặp sự cố này vào tháng trước. Vui lòng sử dụng mã này.

/******************************************************************************************/ 

// 
// text.m 
// 

/******************************************************************************************/ 

@interface drawtext : NSObject { 

    // name of the font to be used 
    NSString *fontname; 

    // instantiations of that font, at size 20 and at size 40, and at the currently-best size 
    NSFont *font20, *font40, *font; 

    // first sizing function: rendered string height as a function of the font-size attribute 
    CGFloat mh, bh; 

    // second sizing function: rendered string width as a function of the font-size attribute 
    CGFloat mw, bw; 

} 

@end 

/******************************************************************************************/ 

@implementation drawtext 

/******************************************************************************************/ 

// CLASS METHODS 

/******************************************************************************************/ 

// The caller specifies the text string (all capitals! no descenders!) to be drawn, the 
// name of the font to use, the box in which to draw the text, and a border if desired. 
// 
// The routine returns the fontsize to be used, and the origin to be used for the 
// "drawAtPoint" message. This will result in the largest rendition of the text string 
// which meets the constraints. 

+ (void) sizeText: (NSString *) captext // the string of text to evaluate for font size 
    usingFontName: (NSString *) fontname // the string name of the font to be employed 
      inBox: (NSRect)  box  // the containing box on the screen 
     withBorder: (NSSize)  border // the # of pixels to leave blank as X & Y borders 
    usingFontSize: (CGFloat *) fontsize // (returned) what font-size to use 
     atOrigin: (NSPoint *) origin // (returned) where to execute the drawAtPoint 
{ 
    // let's start by redefining the containing box to presume the borders 

    NSRect newBox; 
    newBox.origin.x = box.origin.x + border.width; 
    newBox.origin.y = box.origin.y + border.height; 
    newBox.size.width = box.size.width - 2.0 * border.width; 
    newBox.size.height = box.size.height - 2.0 * border.height; 

    // find out dimensions at font size = 20, then at font size = 40, to use for extrapolation 

    NSSize s20, s40; 

    NSFont *f20 = [NSFont fontWithName:fontname size:20]; 
    NSMutableAttributedString *mtext20 = [[NSMutableAttributedString alloc] initWithString:captext]; 
    [mtext20 addAttribute:NSFontAttributeName value:f20 range:NSMakeRange(0,[mtext20 length])]; 
    s20.width = mtext20.size.width; 
    s20.height = f20.capHeight; 

    NSFont *f40 = [NSFont fontWithName:fontname size:40]; 
    NSMutableAttributedString *mtext40 = [[NSMutableAttributedString alloc] initWithString:captext]; 
    [mtext40 addAttribute:NSFontAttributeName value:f40 range:NSMakeRange(0,[mtext40 length])]; 
    s40.width = mtext40.size.width; 
    s40.height = f40.capHeight; 

    // hsize is "font size to cause height of rendered string to match box height" 
    // wsize is "font size to cause width of rendered string to match box width" 

    CGFloat x1, x2, y1, y2, m, b, hsize, wsize; 

    // cap height as function of text size, in y = mx + b format 

    x1 = 20; 
    y1 = s20.height; 
    x2 = 40; 
    y2 = s40.height; 
    m = (y2 - y1)/(x2 - x1); 
    b = y1 - (m * x1); 
    hsize = (newBox.size.height - b)/m; 

    // string len as function of text size, y = mx + b format 

    x1 = 20; 
    y1 = s20.width; 
    x2 = 40; 
    y2 = s40.width; 
    m = (y2 - y1)/(x2 - x1); 
    b = y1 - (m * x1); 
    wsize = (newBox.size.width - b)/m; 

    // choose the lesser of the two extrapolated font-sizes to fit the string into the box, 
    // and at the same time, find the origin point at which to render the string 
    // 
    // if (hsize < wsize) { // there will be east-west spaces 
    // else { // there will be north-south spaces 

    *fontsize = fmin(hsize, wsize); 

    NSSize textSize; 

    NSMutableAttributedString *mtext = [[NSMutableAttributedString alloc] initWithString:captext]; 
    NSFont *f = [NSFont fontWithName:fontname size:*fontsize]; 
    [mtext addAttribute:NSFontAttributeName value:f range:NSMakeRange(0,[mtext length])]; 
    textSize.width = mtext.size.width; 
    textSize.height = f.capHeight; 

    // don't forget "descender", as this is an all-caps string (strings with descenders are 
    // left as an extra credit exercise for the reader :) 
    origin->y = newBox.origin.y + f.descender + ((newBox.size.height/2.0) - (textSize.height/2.0)); 
    origin->x = (newBox.origin.x + (newBox.size.width/2.0)) - (textSize.width/2.0); 
} 

/******************************************************************************************/ 

// Like the previous routine, except the font size is specified by the caller (this is 
// employed in the case it is desired that various text strings, in different containing 
// boxes, are to be drawn in the same font size). 

+ (void) placeText: (NSString *) captext // the string of text to evaluate for positioning 
    usingFontName: (NSString *) fontname // the string name of the font to be employed 
      inBox: (NSRect)  box  // the containing box on the screen 
     withBorder: (NSSize)  border // the # of pixels to leave blank as X & Y borders 
    usingFontSize: (CGFloat) fontsize // (passed) what font-size to use 
      atOrigin: (NSPoint *) origin // (returned) where to execute the drawAtPoint 
{ 
    NSRect newBox; 

    newBox.origin.x = box.origin.x + border.width; 
    newBox.origin.y = box.origin.y + border.height; 
    newBox.size.width = box.size.width - 2.0 * border.width; 
    newBox.size.height = box.size.height - 2.0 * border.height; 

    NSSize textSize; 

    NSMutableAttributedString *mtext = [[NSMutableAttributedString alloc] initWithString:captext]; 
    NSFont *f = [NSFont fontWithName:fontname size:fontsize]; 
    [mtext addAttribute:NSFontAttributeName value:f range:NSMakeRange(0,[mtext length])]; 
    textSize.width = mtext.size.width; 
    textSize.height = f.capHeight; 

    // don't forget "descender", as this is an all-caps string 
    origin->y = newBox.origin.y + f.descender + ((newBox.size.height/2.0) - (textSize.height/2.0)); 
    origin->x = (newBox.origin.x + (newBox.size.width/2.0)) - (textSize.width/2.0); 
} 

/******************************************************************************************/ 

// This routine actually draws the text (the previous routines only determine how it 
// should be drawn). 
// 
// The second routine can be used to draw a string with attributes such as color (i.e., 
// attributes which don't affect the size of the rendered string). 

+ (void) drawText: (NSString *) captext // the string of text to be drawn 
    usingFontName: (NSString *) fontname // the string name of the font to be employed 
     andFontSize: (CGFloat)  fontsize // what font-size to use 
     atOrigin: (NSPoint)  origin // where to execute the drawAtPoint 
{ 
    NSMutableAttributedString *mtext = [[NSMutableAttributedString alloc] initWithString:captext]; 
    NSFont *f = [NSFont fontWithName:fontname size:fontsize]; 
    [mtext addAttribute:NSFontAttributeName value:f range:NSMakeRange(0,[mtext length])]; 
    [mtext drawAtPoint:origin]; 
} 

+ (void) drawMText: (NSMutableAttributedString *) captext // the string of Mtext to be drawn 
    usingFontName: (NSString *) fontname // the string name of the font to be employed 
     andFontSize: (CGFloat)  fontsize // what font-size to use 
     atOrigin: (NSPoint)  origin // where to execute the drawAtPoint 
{ 
    NSFont *f = [NSFont fontWithName:fontname size:fontsize]; 
    [captext addAttribute:NSFontAttributeName value:f range:NSMakeRange(0,[captext length])]; 
    [captext drawAtPoint:origin]; 
} 

/******************************************************************************************/ 

// INSTANCE METHODS 

/******************************************************************************************/ 

// When you instantiate the object, you set the font; from this, you can elucidate the 
// first of the two sizing functions: rendered string height as a function of the 
// font-size attribute. The function is stored in the instance variables of the object, 
// in the variables { mh, bh }, to be used with the classic "y(x) = mx + b" format, where: 
// 
//  y is rendered string height 
//  m is mh 
//  x is font size attribute 
//  b is bh 

- (id) initUsingFontName: (NSString *) fname // string name of font to be employed 
{ 
    if (!self) self = [super init]; 

    fontname = [[NSString alloc] initWithString:fname]; 

    font20 = [NSFont fontWithName:fontname size:20]; 
    font40 = [NSFont fontWithName:fontname size:40]; 

    // "cap height as function of text size", in y = mx + b format (mh is m, bh is b) 

    CGFloat x1, x2, y1, y2; 

    x1 = 20; 
    y1 = font20.capHeight; 
    x2 = 40; 
    y2 = font40.capHeight; 

    mh = (y2 - y1)/(x2 - x1); 
    bh = y1 - (mh * x1); 

    return self; 
} 

/******************************************************************************************/ 

// After initializing the object, you size a text string; this stores a second sizing 
// function: rendered string width as a function of the font-size attribute, in { mw, bw }. 

- (void) sizeString: (NSString *) captext // one string of text to evaluate for font size 
{ 
    CGFloat x1, x2, y1, y2; 

    NSMutableAttributedString *mtext = 
    [[NSMutableAttributedString alloc] initWithString:captext]; 

    [mtext addAttribute:NSFontAttributeName 
       value:font20 
       range:NSMakeRange(0,[mtext length])]; 

    x1 = 20; 
    y1 = mtext.size.width; 

    [mtext addAttribute:NSFontAttributeName 
       value:font40 
       range:NSMakeRange(0,[mtext length])]; 

    x2 = 40; 
    y2 = mtext.size.width; 

    // "string width as function of text size", in y = mx + b format (mw is m, bw is b) 

    mw = (y2 - y1)/(x2 - x1); 
    bw = y1 - (mw * x1); 
} 

/******************************************************************************************/ 

// Then to draw the text string in a box, you use this routine, which will draw it at the 
// largest size possible given all the constraints, including the provided box and border. 
// 
// A similar routine is provided following this one, to draw a mutable string which may 
// contain attributes, such as color, which do not affect the size of the rendered string. 

- (void) drawString: (NSString *) captext // string of text to be drawn 
       inBox: (NSRect)  box  // containing box on the screen 
     withBorder: (NSSize)  border // # of pixels to leave blank as X & Y borders 
{ 
    NSRect newBox; 

    newBox.origin.x = box.origin.x + border.width; 
    newBox.origin.y = box.origin.y + border.height; 
    newBox.size.width = box.size.width - 2.0 * border.width; 
    newBox.size.height = box.size.height - 2.0 * border.height; 

    // solve linear sizing functions for text size, and choose the smaller text size 
    // 
    // if (hsize < wsize) there will be east-west spaces 
    // if (wsize < hsize) there will be north-south spaces 

    CGFloat hsize, wsize, fontsize; 

    hsize = (newBox.size.height - bh)/mh; 
    wsize = (newBox.size.width - bw)/mw; 

    fontsize = fmin(hsize, wsize); 

    font = [NSFont fontWithName:fontname size:fontsize]; 

    NSMutableAttributedString *mtext = 
    [[NSMutableAttributedString alloc] initWithString:captext]; 

    [mtext addAttribute:NSFontAttributeName value:font range:NSMakeRange(0,[mtext length])]; 

    // find the origin-point at which to render the given string, 
    // so that the text is centered in the box 

    NSSize textSize; 

    textSize.width = mtext.size.width; 
    textSize.height = font.capHeight; 

    NSPoint origin; 

    origin.y = newBox.origin.y + font.descender + 
       ((newBox.size.height/2.0) - (textSize.height/2.0)); 
    origin.x = (newBox.origin.x + (newBox.size.width/2.0)) - (textSize.width/2.0); 

    [mtext drawAtPoint:origin]; 
} 

/******************************************************************************************/ 

// To draw a mutable text string in a box (a string containing attributes e.g. color, which 
// do not affect the sizing of the rendered string), use this routine. 

- (void) drawMString: (NSMutableAttributedString *) captext // the M-string to be drawn 
       inBox: (NSRect)  box  // containing box on the screen 
      withBorder: (NSSize)  border // # of pixels to leave blank as X & Y borders 
{ 
    NSRect newBox; 

    newBox.origin.x = box.origin.x + border.width; 
    newBox.origin.y = box.origin.y + border.height; 
    newBox.size.width = box.size.width - 2.0 * border.width; 
    newBox.size.height = box.size.height - 2.0 * border.height; 

    // solve linear sizing functions for text size, and choose the smaller text size 
    // 
    // if (hsize < wsize) there will be east-west spaces 
    // if (wsize < hsize) there will be north-south spaces 

    CGFloat hsize, wsize, fontsize; 

    hsize = (newBox.size.height - bh)/mh; 
    wsize = (newBox.size.width - bw)/mw; 

    fontsize = fmin(hsize, wsize); 

    font = [NSFont fontWithName:fontname size:fontsize]; 

    [captext addAttribute:NSFontAttributeName 
        value:font 
        range:NSMakeRange(0,[captext length])]; 

    // find the origin-point at which to render the given string, 
    // so that the text is centered in the box 

    NSSize textSize; 

    textSize.width = captext.size.width; 
    textSize.height = font.capHeight; 

    NSPoint origin; 

    origin.y = newBox.origin.y + font.descender + 
       ((newBox.size.height/2.0) - (textSize.height/2.0)); 
    origin.x = (newBox.origin.x + (newBox.size.width/2.0)) - (textSize.width/2.0); 

    [captext drawAtPoint:origin]; 
} 

/******************************************************************************************/ 

@end 

/******************************************************************************************/