सुंदर विकलांग छोटे रक्त प्रतीक

डेल्फी लंबे समय से इस तथ्य के लिए प्रसिद्ध है कि डिफ़ॉल्ट रूप से अक्षम आइकन कुछ इस तरह दिखते हैं:



और मैं चाहूंगा कि वे कुछ इस तरह दिखें:



हम इस तथ्य का लाभ उठाते हैं कि डेल्फी आपको छवियों की एक अतिरिक्त सूची निर्दिष्ट करते हुए, अपने आप से अक्षम आइकन को बदलने की अनुमति देता है। लेकिन हर बार ऐसे आइकॉन को खींचना और जोड़ना एक थकाऊ काम है। इसलिए, हम रनटाइम पर छवियों की इस सूची को गतिशील रूप से बनाएंगे।

हम विशेष फ़ंक्शन CreateSpecialImageList () में छवियों की एक ऐसी सूची बनाएंगे। एक तर्क के रूप में, हमें मूल आइकनों के साथ एक सूची की आवश्यकता होगी, और वापसी मूल्य के रूप में हमारे पास पहले से ही TImageList होगा जिसकी हमें आवश्यकता है। फिर कोड की निम्न पंक्ति के साथ फॉर्म बनाते समय हम अपने नए आइकन कनेक्ट कर सकते हैं:

ActionManager.DisabledImages := CreateSpecialImageList(ImageList); 

लेकिन मुझे लगता है कि हमें गहराई तक जाना चाहिए ...

हम फ़ंक्शन की क्षमताओं का विस्तार करेंगे, न केवल ग्रे पारभासी आइकन बनाने की क्षमता जोड़ेंगे, बल्कि उन्हें उज्जवल या अधिक विपरीत भी बना सकते हैं। HotImages गुणों के लिए आइकन बनाते समय आपको इसकी आवश्यकता हो सकती है। इस प्रकार, हमारे पास कई विशेष राज्यों के प्रतीक बनाने के लिए एक सार्वभौमिक कार्य होगा।

स्रोत कोड:

 function CreateSpecialImageList(ASource: TCustomImageList; ABrightness, AContrast, AGrayscale, AAlpha: Single): TCustomImageList; type PBGRA = ^TBGRA; TBGRA = packed record B, G, R, A: Byte; end; TByteLUT = array [Byte] of Byte; function ByteRound(const Value: Single): Byte; inline; begin if Value < 0 then Result := 0 else if Value > 255 then Result := 255 else Result := Round(Value); end; procedure GetLinearLUT(var LUT: TByteLUT; X1, Y1, X2, Y2: Integer); var X, DX, DY: Integer; begin DX := X2 - X1; DY := Y2 - Y1; for X := 0 to 255 do LUT[X] := ByteRound((X - X1) * DY / DX + Y1); end; function GetBrightnessContrastLUT(var LUT: TByteLUT; const Brightness, Contrast: Single): Boolean; var B, C: Integer; X1, Y1, X2, Y2: Integer; begin X1 := 0; Y1 := 0; X2 := 255; Y2 := 255; B := Round(Brightness * 255); C := Round(Contrast * 127); if C >= 0 then begin Inc(X1, C); Dec(X2, C); Dec(X1, B); Dec(X2, B); end else begin Dec(Y1, C); Inc(Y2, C); Inc(Y1, B); Inc(Y2, B); end; GetLinearLUT(LUT, X1, Y1, X2, Y2); Result := (B <> 0) or (C <> 0); end; var LImageInfo: TImageInfo; LDibInfo: TDibSection; I, L: Integer; P: PBGRA; R, G, B, A: Byte; LUT: TByteLUT; LHasLUT: Boolean; begin Result := nil; if (ASource = nil) or (ASource.ColorDepth <> cd32bit) then Exit; Result := TImageList.Create(ASource.Owner); try Result.ColorDepth := cd32bit; Result.Assign(ASource); Result.Masked := False; FillChar(LImageInfo, SizeOf(LImageInfo), 0); ImageList_GetImageInfo(Result.Handle, 0, LImageInfo); FillChar(LDibInfo, SizeOf(LDibInfo), 0); GetObject(LImageInfo.hbmImage, SizeOf(LDibInfo), @LDibInfo); P := LDibInfo.dsBm.bmBits; LHasLUT := GetBrightnessContrastLUT(LUT, ABrightness, AContrast); for I := 0 to LDibInfo.dsBm.bmHeight * LDibInfo.dsBm.bmWidth - 1 do begin A := PA; R := MulDiv(PR, $FF, A); G := MulDiv(PG, $FF, A); B := MulDiv(PB, $FF, A); if LHasLUT then begin R := LUT[R]; G := LUT[G]; B := LUT[B]; end; if AGrayscale > 0 then begin L := (R * 61 + G * 174 + B * 21) shr 8; if AGrayscale >= 1 then begin R := L; G := L; B := L; end else begin R := ByteRound(R + (L - R) * AGrayscale); G := ByteRound(G + (L - G) * AGrayscale); B := ByteRound(B + (L - B) * AGrayscale); end; end; if AAlpha <> 1 then begin A := ByteRound(A * AAlpha); PA := A; end; PR := MulDiv(R, A, $FF); PG := MulDiv(G, A, $FF); PB := MulDiv(B, A, $FF); Inc(P); end; except FreeAndNil(Result); end; end; 

कार्य तर्क:

• स्रोत - स्रोत छवि सूची
• चमक - चमक, -1 से 1 तक, अनुशंसित सीमा -0.5 से 0.5 तक है
• AContrast - कंट्रास्ट, -1 से 1 तक, अनुशंसित रेंज -0.5 से 0.5 तक
• AGrayscale - ग्रेस्केल, 0 से - मूल रंग 1 से - पूरी तरह से ग्रे
• AAlpha - पारदर्शिता, 0 से - पूरी तरह से पारदर्शी 1 - प्रारंभिक पारदर्शिता

मुझे लगता है कि फ़ंक्शन का स्रोत कोड अधिकांश डॉल्फ़िस्टों के लिए समझ में आएगा, लेकिन मैं कुछ बिंदुओं को स्पष्ट करना आवश्यक समझता हूं।

सबसे पहले, TImageList में DIB की छवि को एक प्रीमियर फॉर्मेट में संग्रहित किया जाता है और प्रत्येक पिक्सेल के लिए हमें कॉल की श्रृंखला का मूल मूल्‍य मूल्‍िव () के साथ रंगीन चैनल प्राप्त करने का संचालन करना चाहिए, ऑपरेशन करना चाहिए, और मूल पिक्सेल प्रारूप को वापस करना चाहिए।

चमक और कंट्रास्ट बदलना LUT (लुकअप टेबल) - लुकअप टेबल का उपयोग करके किया जाता है। हम 2 बिंदुओं पर एक रैखिक फ़ंक्शन के आधार पर एक तालिका बनाते हैं। चमक और कंट्रास्ट पैरामीटर केवल वांछित दिशाओं में प्रत्यक्ष सुधार के शुरुआती बिंदुओं को स्थानांतरित करते हैं। चूंकि हम सभी रंग चैनलों पर समान सुधार करते हैं, इसलिए हम केवल एक LUT का उपयोग करते हैं।

एक पिक्सेल के लिए ग्रेस्केल को बदलना, मूल मूल्य से ऑफसेट को कुल रंग चमक मान की गणना करके किया जाता है। एग्रीसेकेल के तर्क का बड़ा मूल्य, समग्र चमक के मूल्य के करीब नया मूल्य, जो सभी रंग चैनलों के लिए एक साथ ग्रे के लिए एक सन्निकटन देता है।

समारोह का उपयोग करें

फ़ंक्शन का उपयोग करने के लिए, आप स्रोत कोड को अपनी परियोजना में कॉपी कर सकते हैं। फ़ंक्शन कोड स्व-निहित है और इसे तृतीय-पक्ष घटकों या मॉड्यूल की आवश्यकता नहीं है। सुविधा के लिए, मैंने एक छोटा डेमो लिखा जिसमें आप फ़ंक्शन तर्कों के साथ प्रयोग कर सकते हैं। डेमो का सोर्स कोड यहां डाउनलोड किया जा सकता है ।

मूल प्रतीक

मानक अक्षम अवस्था में मूल चिह्न

इसके विपरीत प्रतीक 10% की वृद्धि हुई

विकलांग अवस्था में प्रतीक पूरी तरह से भूरे रंग के होते हैं और पारदर्शिता 50% तक कम हो जाती है

मुझे उम्मीद है कि यहां दिए गए फ़ंक्शन आपके डिजाइनों में आपके लिए उपयोगी हैं। एक अच्छा कोडिंग है!

UPD : यह विधि केवल ColorDepth = cd32bit मोड में छवि सूचियों के लिए काम करती है।

UPD2 :: संकलित डेमो प्रोजेक्ट शुरू करते समय, आइकन के चारों ओर "ब्लैक" पृष्ठभूमि दिखाई दे सकती है, प्रोजेक्ट का नया संस्करण डाउनलोड करें । डेल्फी एक्सई 3 से डेल्फी एक्सई के लिए परियोजना के गलत हस्तांतरण के कारण समस्या उत्पन्न हुई।

UPD3 : 32 बिट अक्षम आइकनों के लिए विंडोज 2000 पर चलने पर, एक डिमिंग प्रभाव प्राप्त होता है। इस समस्या को हल करने के लिए, आप ओएस निर्धारित कर सकते हैं और 2000 वीं छुट्टी के लिए AAlpha = 1 छोड़ दें, फिर आइकन सिर्फ ग्रे होंगे।