Oldesu,

jak sem si stahl novou verzi tech wb-skinz, tak sem si uvedomil, ze sem
ti zapomel rict jeste o jedne zmene, kterou sem tam udelal:

'radio sem upravil, takze kdyz das do layoutu napr [radio "Radio1" skin
'akward] tak se zobrazi radiobutton aji s textem a ten text je aktivni
(da se zmacknout aji na neho a clovek se nemusi trefovat jen do cudliku
- vlastne jako ve windows).

Takze sorry, vidim, ze ty ostatni zmeny's tam zakomponoval, tak ja ti
posilam upravenou verzi, kde je aji vylepseny 'radio.

A mimochodem, kdyz spoustis %wb-styles.r, tak predpokladas, ze 'site je
nastaveny na http://oldes.multimeda.cz , coz samzrejme neni vzdycky
pravda, takze do objektu 'wb-skinner sem dodelat 'site a ted uz to
funguje.

Jo, ted sem doupravoval aji 'wb-check, takze funguje jako 'wb-radio.

Tak se nejak ozvi, zdarec palec, bolek

---
Odchozí zpráva neobsahuje viry.
Zkontrolováno antivirovým systémem AVG (http://www.grisoft.cz).
Verze: 6.0.381 / Virová báze: 214 - datum vydání: 2.8.2002
 
  

-- Attached file included as plaintext by Listar --
-- File: wb-skinz.r

rebol []
wb-skiner: make object! [
        site: http://oldes.multimedia.cz/
        skinz: [
                default [
                        radio [%aquarium/radio.bmp 14 4]
                        check [%aquarium/checkbox.bmp 14 4]
                        button [%aquarium/button.bmp 54 5]
                        arrows [%aquarium/arrows.bmp 16 23]
                        HorzScroll [%aquarium/hscroll_back.bmp 47 4]
                        HorzScrollThumb [%aquarium/hscroll_bar.bmp 69 3]
                        VertScroll [%aquarium/vscroll_back.bmp 16 4]
                        VertScrollThumb [%aquarium/vscroll_bar.bmp 16 3]
                ]
                eplus [
                        radio [ %eplus/radio.bmp 13 4]
                        button [%eplus/button.bmp 26 5]
                ]
                wbmaniaiii [
                        radio [ %wbmaniaiii/radiobox.bmp 14 4]
                        button [%wbmaniaiii/button.bmp 56 5]
                ]
                imac [
                        radio [%imac/radiobutton.bmp 14 4]
                        check [%imac/checkbox.bmp 14 4]
                        button [%imac/button.bmp 26 5]
                        arrows [%imac/scrollar.bmp 16 23]
                        ShowDot? on
                        HorzScroll [%imac/scrollhz.bmp 16 4]
                        HorzScrollThumb [%imac/scrollhb.bmp 16 3]
                        VertScroll [%imac/scrollvt.bmp 16 4]
                        VertScrollThumb [%imac/scrollvb.bmp 16 3]
                ]
                maxwbgold [
                        check [%maxwbgold/checkbox.bmp 14 4]
                        radio [%maxwbgold/radiobutton.bmp 14 4]
                        button [%maxwbgold/bms.bmp 40 5]
                        arrows [%maxwbgold/arrows.bmp 16 23]
                        ShowDot? on
                        HorzScroll [%maxwbgold/hscroll.bmp 16 4]
                        HorzScrollThumb [%maxwbgold/hscroll2.bmp 16 3]
                        VertScroll [%maxwbgold/vscroll.bmp 16 4]
                        VertScrollThumb [%maxwbgold/vscroll2.bmp 16 3]
                ]
        ]
        cutImage: func[img width count /local imgz sz][
                imgz: make block! count
                sz: to-pair reduce [width img/size/y]
                for i 0 1 - count -1 [
                        append imgz to-image layout/size/origin compose [
                                at (to-pair reduce [i * width 0])
                                image img
                        ] sz 0x0
                ]
                imgz
        ]
        get-images: func[type [word!] /skin skname /local data images][
                skname: either skin [skname]['default]
                either none? images: find/tail select skinz skname type [
                        return none
                ][
                        data: first images
                        if not block? data [return data]
                        if file? first data [
                                change/only images (
                                        cutImage load read-thru rejoin [site/skinz 
#"/" data/1] data/2 data/3
                                )
                        ]
                        return (first images)
                ]
        ]
]


wb-styles: stylize [
        wb-button: button with [
                skin: 'default
                edge: none
                over?: false
                feel: make feel [
                redraw: func [face act pos /local state][
                    if all [face/texts face/texts/2] [
                        face/text: either face/state [face/texts/2] [face/texts/1]
                    ] 
                    either face/images [
                        face/image: either face/state [face/images/2] [
                                                either face/over? [     last 
face/images ][ face/images/1 ]
                                        ] 
                        if all [face/colors face/effect find face/effect 'colorize] [
                            change next find face/effect 'colorize pick face/colors 
not face/state
                        ]
                    ] [
                        if face/edge [face/edge/effect: pick [ibevel bevel] 
face/state] 
                        state: either not face/state [face/blinker] [true] 
                        if face/colors [face/color: pick face/colors not state] 
                        if face/effects [face/effect: pick face/effects not state]
                    ]
                ]
                        over: func [face action event][
                                face/over?: not face/over?
                if all [face/font face/font/colors] [
                        face/font/color: pick face/font/colors not action 
                        show face 
                        face/font/color: first face/font/colors
                    ]
                ]
                engage: func [face action event][
                switch action [
                        time [if not face/state [face/blinker: not face/blinker]] 
                        down [face/state: on] 
                        alt-down [face/state: on] 
                        up [face/over?: off if face/state [do-face face face/text] 
face/state: off] 
                        alt-up [if face/state [do-face-alt face face/text] face/state: 
off] 
                        over [face/over?: face/state: on] 
                        away [face/over?: face/state: off]
                    ] 
                    cue face action 
                    show face
                ]
                ]
                images: none
                init: [
                        images: wb-skiner/get-images/skin 'button skin
                        image: first images
                        if not none? color [
                        
                        ]
                        color: none
                        
                        either size <> image/size [
                                if none? effect [effect: copy []]
                                append effect compose [
                                        extend (image/size / 2) (size - image/size)
                                ]
                        ][
                                ;size: image/size
                        ]
                        either block? effect [
                                insert effect [merge key 255.0.255]
                        ][      effect: [merge key 255.0.255] ]
                ]
                words: [
                        skin [new/skin: second args next args]
                ]
                multi: make multi [
                        color: func [face blk][
                                if pick blk 1 [
                                        either block? face/effect [
                                                repend face/effect ['colorize pick blk 
1]
                                        ][
                                                face/effect: reduce ['colorize pick 
blk 1]
                                        ]
                                ]
                        ]
                ]
        ]
        wb-toggle: wb-button with [
                feel: make feel [
                        engage: get in system/view/vid/vid-feel/toggle 'engage
                ]
        ]
        wb-rotary: wb-button with [
                feel: make feel [
                        redraw: func [face act pos /local state][
                                face/text: face/data/1
                    either face/images [
                        face/image: either face/state [face/images/2] [
                                                either face/over? [     last 
face/images ][ face/images/1 ]
                                        ]
                        if all [face/colors face/effect find face/effect 'colorize] [
                            change next find face/effect 'colorize pick face/colors 
not face/state
                        ]
                    ] [
                        if face/edge [face/edge/effect: pick [ibevel bevel] face/state]
                        state: either not face/state [face/blinker] [true]
                        if face/colors [face/color: pick face/colors not state]
                        if face/effects [face/effect: pick face/effects not state]
                    ]
                ]
                        engage: func [face action event /local do-it down-it][
                                do-it: [if face/state [do-face face face/data/1] 
face/over?: face/state: off]
                                down-it: [if not face/state [next-face face] 
face/over?: face/state: on]
                switch action [
                        time [if not face/state [face/blinker: not face/blinker]]
                        down down-it
                        alt-down [face/state: on]
                        up do-it
                        alt-up do-it
                        over down-it
                        away [face/over?: face/state: off]
                    ]
                    cue face action
                    show face
                ]
                next-face: func [face][
                    face/data: either tail? next face/data [head face/data] [next 
face/data]
            ]
                back-face: func [face][
                    face/data: either head? face/data [back tail face/data] [back 
face/data]
            ]
                ]
                multi: make system/view/vid/vid-styles/rotary/multi []
                insert head init [if texts [data: texts]]
        ]
        wb-arrow: arrow with [
                skin: 'default
                disabled?: false
                img-ofs: 0
                over?: false
                edge: none color: none
                feel: make feel [
                        redraw: func [face act pos][
                                face/image: pick face/images face/img-ofs + either 
face/disabled? [3][
                                        either face/state [2][either face/over? [4][1]]
                                ]
                        ]
                        over: func [face action event][
                                face/over?: not face/over?
                                face/image: pick face/images face/img-ofs + 3
                                show face
                ]
                engage: func [face action event][
                switch action [
                        time [if not face/state [face/blinker: not face/blinker]] 
                        down [face/state: on] 
                        alt-down [face/state: on] 
                        up [face/over?: off if face/state [do-face face face/text] 
face/state: off] 
                        alt-up [if face/state [do-face-alt face face/text] face/state: 
off] 
                        over [face/over?: face/state: on] 
                        away [face/over?: face/state: off]
                    ] 
                    cue face action 
                    show face
                ]
                ]
                init: make block! [
                        images: wb-skiner/get-images/skin 'arrows skin
                        image: first images
                        ;size: image/size
                        img-ofs: any [(select [left 0 right 4 up 8 down 12] data) 8]
                        either block? effect [
                                insert effect [merge key 255.0.255 fit]
                        ][      effect: [merge key 255.0.255 fit] ]
                ]
                words: [
                        down [new/data: first args args]
                        up [new/data: first args args]
                        right [new/data: first args args]
                        left [new/data: first args args]
                        skin [new/skin: second args args]
                ]
        ]
]

wb-styles: stylize/styles [
        wb-scroller: slider with [
        speed: 20 
                edge: [size: 0x0]
                skin: 'default
                feel: make feel [
                            redraw: func [face act pos][
                                        face/data: max 0 min 1 face/data
                                        if face/data <> face/state [
                                                pos: face/size - face/pane/2/size - (2 
* face/edge/size) - (2 * face/clip)
                                                either face/size/x > face/size/y [
                                                        face/pane/2/offset/x: 
face/data * pos/x + face/clip/x
                                                ][      face/pane/2/offset/y: 
face/data * pos/y + face/clip/y]
                                                face/state: face/data
                                                show face/pane/2
                                        ]
                                ]
                                detect: none
                                over: none
                                engage: func [f act evt /local tmp][
                                        if act = 'down [
                                                tmp: f/axis
                                                do-face pick reduce [f/pane/4 
f/pane/3] evt/offset/:tmp > f/pane/2/offset/:tmp f/page
                                        ]
                                ]
                        ]
                images: none
                ;ratio: 0.5
                reset: does [data: 0] 
                redrag: func [val /local tmp][
                        min-ratio: either axis = 'y [
                                2 + pane/2/image/size/y / (size/y - 
pane/3/image/size/y - pane/4/image/size/y)
                        ][
                                2 + pane/2/image/size/x / (size/x - 
pane/3/image/size/x - pane/4/image/size/x)
                        ]
                        ratio: min 1 max min-ratio val
                        page: any [all [ratio = 1 0] ratio / (1 - ratio)]
                        pane/2/size: val: size - (2 * edge/size) - (2 * clip * pick 
[0x1 1x0] axis = 'y)
                        tmp: val/:axis * ratio
                        if tmp < 10 [page: either val/:axis = tmp: 10 [1] [tmp / 
(val/:axis - tmp)]]
                        either axis = 'y [
                                pane/2/size/y: tmp
                                if not none? pane/2/pane [
                                        pane/2/pane/offset/y: (pane/2/size/y / 2) - 
(pane/2/pane/image/size/y / 2)
                                ]
                        ] [
                                pane/2/size/x: tmp
                                if not none? pane/2/pane [
                                        pane/2/pane/offset/x: (pane/2/size/x / 2) - 
(pane/2/pane/image/size/x / 2)
                                ]
                        ]
                        pane/2/effect: compose [
                                merge key 255.0.255
                                extend (pane/2/image/size / 2) (pane/2/size - 
pane/2/image/size)
                        ]
                ]
                resize: func [new /x /y /local tmp] [
                        either any [x y] [
                                if x [size/x: new] 
                                if y [size/y: new]
                        ] [
                                size: any [new size]
                        ] 
                        tmp: pick [y x] axis = 'x 
                        clip: pane/3/size: pane/4/size: size/:tmp - (2 * 
edge/size/:tmp) * 1x1 
                        pane/4/offset: size/:axis - pane/4/size/:axis - (2 * 
edge/size/:axis) * 0x1 
                        if tmp: axis = 'x [pane/4/offset: reverse pane/4/offset] 
                        pane/3/data: pick [left up] tmp 
                        pane/4/data: pick [right down] tmp 
                        state: pane/3/effect: pane/4/effect: none 
                        do pane/3/init do pane/4/init 
                        pane/2/effect: compose [
                                merge key 255.0.255
                                extend (pane/2/image/size / 2) (pane/2/size - 
pane/2/image/size)
                        ]
                        either axis = 'x [
                                pane/1/offset/x: pane/3/size/x
                                pane/1/size/x: size/x - pane/3/size/x - pane/4/size/x
                                pane/1/effect: compose [
                                        ;merge key 255.0.255
                                        extend (pane/1/image/size / 2) (1x0 * 
(pane/1/size - pane/1/image/size))
                                ]
                        ][
                                pane/1/offset/y: pane/3/size/y
                                pane/1/size/y: size/y - pane/3/size/y - pane/4/size/y
                                pane/1/effect: compose [
                                        ;merge key 255.0.255
                                        extend (pane/1/image/size / 2) (0x1 * 
(pane/1/size - pane/1/image/size))
                                ]
                        ]
                        pane/2/offset: 0x0 
                        redrag any [ratio 0.1]
                ] 
                init: [
                        pane: reduce [
                                make face [
                                        edge: none
                                        images: none
                                        skin: 'default
                                ]
                                make dragger [
                                        edge: none
                                        images: none
                                        color: none
                                        skin: 'default
                                        over?: false
                                        state: off
                                feel: make object! [
                                                redraw: func [f a p][
                                                        f/image: either f/state 
[f/images/2] [
                                                                either f/over? [last 
f/images ][ f/images/1 ]
                                                        ] 
                                                ]
                                                detect: none
                                                over: func [f a e][f/over?: a show f ]
                                                engage: func [f a e][
                                                        switch a [
                                                down [f/state: on f/data: e/offset] 
                                                up [f/over?: f/state: off] 
                                                over [f/over?: f/state: on 
svvf/drag-off f/parent-face f f/offset + e/offset - f/data] 
                                                away [f/over?: off svvf/drag-off 
f/parent-face f f/offset + e/offset - f/data]
                                            ] 
                                                        show f
                                                ]
                                        ]
                                ] 
                                axis: make get-style/styles 'wb-arrow wb-styles [
                                        img-ofs: 0
                                        dir: -1
                                        action: get in svvf 'move-drag
                                        images: none
                                        feel: make feel [
                                        engage: func [f a e][
                                        switch a [
                                                down [f/state: flag: on do-face f 
f/parent-face/step f/rate: 4] 
                                                alt-down [f/state: on] 
                                                up [f/over?: f/state: flag: off 
f/rate: none] 
                                                alt-up [if f/state [do-face-alt f 
f/text] f/state: off] 
                                                over [
                                                                        f/over?: 
f/state: on
                                                                        if flag 
[f/rate: f/parent-face/speed]
                                                                ]
                                                away [f/over?: f/state: off f/rate: 
none]
                                                                time [
                                                                        either flag [
                                                                                either 
f/rate <> f/parent-face/speed [
                                                                                       
 f/rate: f/parent-face/speed
                                                                                ][     
 do-face f f/parent-face/step]
                                                                        ][flag: on 
exit]
                                                                ]
                                            ] 
                                            cue f a
                                            show f
                                        ]
                                        ]
                                        ;feel: make svvf/scroll-button []
                                ] 
                                make axis [dir: 1 img-ofs: 4 data: 'right]
                        ]
                        pane/1/skin: pane/2/skin: pane/3/skin: pane/4/skin: skin
                        pane/3/images: pane/4/images: wb-skiner/get-images/skin 
'arrows skin
                        pane/3/image: first pane/3/images
                        pane/4/image: fifth pane/4/images
                        
                        either size/y >= size/x [
                                axis: 'y
                                pane/1/images: wb-skiner/get-images/skin 'VertScroll 
skin
                                pane/1/image: first pane/1/images
                                pane/2/images: wb-skiner/get-images/skin 
'VertScrollThumb skin
                                pane/2/image: first pane/2/images
                        ][
                                axis: 'x
                                pane/1/images: wb-skiner/get-images/skin 'HorzScroll 
skin
                                pane/1/image: first pane/1/images
                                pane/2/images: wb-skiner/get-images/skin 
'HorzScrollThumb skin
                                pane/2/image: first pane/2/images
                        ]
                        pane/2/size: pane/2/image/size
                        if wb-skiner/get-images/skin 'ShowDot? skin [
                                pane/2/pane: make face [
                                        color: none
                                        edge: none
                                        images: none
                                        effect: [key 255.0.255]
                                        images: wb-skiner/get-images/skin 'arrows skin
                                        feel: make feel [
                                                over: func [f a e][
                                                        f/parent-face/over?: a show 
f/parent-face
                                        ]
                                        ]
                                ]
                                either axis = 'x [
                                        pane/2/pane/image: pane/2/pane/images/17
                                ][
                                        pane/2/pane/image: pane/2/pane/images/20
                                ]
                                pane/2/pane/size: pane/2/pane/image/size
                                
                        ]
                        ;axis: pick [y x] size/y >= size/x 
                        resize size
                ]
                words: [
                        skin [new/skin: second args next args]
                ]
        ]
        wb-radio: radio with [
                skin: 'default
                size: 14x13
                image: none
                color: none
                edge: make face/edge [size: 0x3 color: effect: none]
                disabled?: false
                feel: make feel [
                        redraw: func [face act pos][
                                face/image: either face/disabled? [
                                        either face/data [
                                                fourth face/images
                                        ][  third  face/images ]
                                ][
                                        either face/data [
                                                second face/images
                                        ][  first  face/images ]
                                ]
                        ]
                        over: func [face action][
                                face/font/color: face/font/colors/:action
                                show face
                        ]
                        engage: func [face action event][
                                if not face/disabled? [
                        if action = 'down [
                                foreach item face/parent-face/pane [
                                    if all [flag-face? item radio item/related = 
face/related item/data][
                                                                item/data: false show 
item
                                                        ]
                                                ]
                        ] 
                        do-face face face/data: true 
                        show face
                                ]
            ]
                ]
                font: make face/font [color: 255.255.255 style: 'bold shadow: 1x1 
colors: [255.180.75 255.255.255]]
                para: make face/para [scroll: 5x-2]
                init: make block! [
                        font: make font []
                        images: wb-skiner/get-images/skin 'radio skin
                        image: first images
                        size: 10000000x100
                        size: (1x0 * image/size) + (size-text self )+ (2 * edge/size)
                        either block? effect [
                                insert effect [merge key 255.0.255]
                        ][      effect: [merge key 255.0.255] ]
                ]
                words: [
                        skin [new/skin: second args next args]
                ]
        ]
        wb-check: check with [
                skin: 'default
                disabled?: false
                edge: none
                color: none
                feel: make feel [
                        redraw: func [face act pos][
                                face/image: either face/disabled? [
                                        either face/data [
                                                fourth face/images
                                        ][  third  face/images ]
                                ][
                                        either face/data [
                                                second face/images
                                        ][  first  face/images ]
                                ]
                        ]
                        over: func [face action][
                                face/font/color: face/font/colors/:action
                                show face
                        ]
                        engage: func [face action event][
                                if not face/disabled? [
                            if action = 'down [
                                if face/related [
                                    foreach item face/parent-face/pane [
                                        if all [flag-face? item check item/related 
item/related = face/related item/data] [item/data: false show item]
                                ]
                                ] 
                                do-face face face/data: not face/data 
                                show face
                            ]
                                ]
                ]
                ]
                font: make face/font [color: 255.255.255 style: 'bold shadow: 1x1 
colors: [255.180.75 255.255.255]]
                para: make face/para [scroll: 5x-2]
                edge: make face/edge [size: 0x3 color: effect: none]
                init: make block! [
                        font: make font []
                        images: wb-skiner/get-images/skin 'check skin
                        image: first images
                        size: 10000000x100
                        size: (1x0 * image/size) + (size-text self )+ (2 * edge/size)
                        either block? effect [
                                insert effect [merge key 255.0.255]
                        ][      effect: [merge key 255.0.255] ]
                ]
                words: [
                        skin [new/skin: second args next args]
                ]
        ]
        wb-updown: box with [
                size: 100x16
                skin: 'maxwbgold
                color: none
        step: 1
        min-val: none
        max-val: none
        value: 0
        wrap?: false
        edit?: false  
        line-list: action: none
        list-data: copy []
        bounds: func [val][
            any [
                    if all [min-val val < min-val][either wrap? [val: max-val][val: 
min-val]]
                    if all [max-val val > max-val][either wrap? [val: min-val][val: 
max-val]]
            ]
            val
        ]
                fld: none
        button-action: func [act /local val][
            if system/view/focal-face = self [
                ; user has started an edit, so double check data
                either all [
                    not error? try [val: load fld/text] 
                    number? val
                ][
                     fld/text: form fld/value: val
                ][ 
                     fld/text: form fld/value
                     show fld
                     exit
                ] 
                unfocus
            ]
            switch act [
                inc [either error? try [val: add fld/value step][fld/text: form 
fld/value][
                    val: bounds val
                    fld/text: form fld/value: val]
                ]
                dec [either error? try [val: subtract fld/value step][fld/text: form 
fld/value][
                    val: bounds val
                    fld/text: form fld/value: val]
                ]
            ]
            show fld
            ; sprint reduce [val step max-val min-val self/text self/value]
        ]

                pane: reduce [
                        arrow: make get-style/styles 'wb-arrow wb-styles [
                                img-ofs: 0 action: [parent-face/button-action 'dec]
                        ]
                        make arrow [img-ofs: 4 action: [parent-face/button-action 
'inc]]
                        make get-style 'field [
                                size: 60x16
                                value: none
                                edge: make edge [effect: none color: 0.0.0 size: 1x1]
                                font: make font [style: 'bold size: 11 offset: 2x0 
valign: none align: 'center]
                        ]
                ]
        words: [min-val  [new/min-val: second args next args]
                max-val  [new/max-val: second args next args]
                step     [new/step: second args next args]
        ]

                init: [
                        pane/1/skin: pane/2/skin: skin
                        pane/1/images: pane/2/images: wb-skiner/get-images/skin 
'arrows skin
                        pane/1/image: first pane/1/images
                        pane/2/image: fifth pane/2/images
                        pane/2/offset/x: 76
                        fld: pane/3
                        fld/value: load text
                        fld/offset/x: 16
                        fld/text: text
                        text: none
;                       tmp/offset: offset
        ;               self: tmp
                ;       ? self
                        ;unset 'tmp
        ;               self: tmp
                ]
        ]
] wb-styles
-- 
To unsubscribe from this list, please send an email to
[EMAIL PROTECTED] with "unsubscribe" in the 
subject, without the quotes.

Reply via email to