diff --git a/fontello.config.json b/fontello.config.json index 6341b8a3..cfc7aaa9 100644 --- a/fontello.config.json +++ b/fontello.config.json @@ -573,6 +573,12 @@ "css": "left-open", "code": 59446, "src": "fontawesome" + }, + { + "uid": "c8585e1e5b0467f28b70bce765d5840c", + "css": "docs", + "code": 61637, + "src": "fontawesome" } ] } \ No newline at end of file diff --git a/package.json b/package.json index 4c66a905..f5a8e834 100755 --- a/package.json +++ b/package.json @@ -1,7 +1,7 @@ { "name": "frankerfacez", "author": "Dan Salvato LLC", - "version": "4.14.6", + "version": "4.14.7", "description": "FrankerFaceZ is a Twitch enhancement suite.", "license": "Apache-2.0", "scripts": { diff --git a/res/font/ffz-fontello.eot b/res/font/ffz-fontello.eot index 6701eb45..64d32e1b 100644 Binary files a/res/font/ffz-fontello.eot and b/res/font/ffz-fontello.eot differ diff --git a/res/font/ffz-fontello.svg b/res/font/ffz-fontello.svg index 8452e46e..bf9b1ac9 100644 --- a/res/font/ffz-fontello.svg +++ b/res/font/ffz-fontello.svg @@ -122,6 +122,8 @@ + + diff --git a/res/font/ffz-fontello.ttf b/res/font/ffz-fontello.ttf index 29f79c4a..72aba6f0 100644 Binary files a/res/font/ffz-fontello.ttf and b/res/font/ffz-fontello.ttf differ diff --git a/res/font/ffz-fontello.woff b/res/font/ffz-fontello.woff index be309ffd..ed9edb85 100644 Binary files a/res/font/ffz-fontello.woff and b/res/font/ffz-fontello.woff differ diff --git a/res/font/ffz-fontello.woff2 b/res/font/ffz-fontello.woff2 index 398054b0..ce4a84c6 100644 Binary files a/res/font/ffz-fontello.woff2 and b/res/font/ffz-fontello.woff2 differ diff --git a/src/modules/main_menu/components/profile-manager.vue b/src/modules/main_menu/components/profile-manager.vue index a80becc7..fd8bd7d9 100644 --- a/src/modules/main_menu/components/profile-manager.vue +++ b/src/modules/main_menu/components/profile-manager.vue @@ -324,11 +324,10 @@ export default { importProfile(profile_data, data) { this.import_profile = profile_data; + this.import_profile_data = data; - if ( profile_data.url ) { - this.import_profile_data = data; + if ( profile_data.url ) return; - } this.confirmImport(false); }, @@ -342,6 +341,8 @@ export default { if ( ! allow_update ) delete profile_data.url; + console.log('Importing', profile_data, data, this.import_data); + const prof = this.context.createProfile(profile_data); prof.update({ diff --git a/src/modules/metadata.jsx b/src/modules/metadata.jsx index d3840169..547ced89 100644 --- a/src/modules/metadata.jsx +++ b/src/modules/metadata.jsx @@ -7,7 +7,7 @@ import {createElement, ClickOutside, setChildren} from 'utilities/dom'; import {maybe_call} from 'utilities/object'; -import {duration_to_string} from 'utilities/time'; +import {duration_to_string, durationForURL} from 'utilities/time'; import Tooltip from 'utilities/tooltip'; import Module from 'utilities/module'; @@ -75,6 +75,9 @@ export default class Metadata extends Module { this.definitions.uptime = { + inherit: true, + no_arrow: true, + refresh() { return this.settings.get('metadata.uptime') > 0 }, setup(data) { @@ -89,7 +92,8 @@ export default class Metadata extends Module { return { created, - uptime: created ? Math.floor((now - created.getTime()) / 1000) : -1 + uptime: created ? Math.floor((now - created.getTime()) / 1000) : -1, + getBroadcastID: data.getBroadcastID } }, @@ -118,11 +122,66 @@ export default class Metadata extends Module { '(since {since,datetime})', {since: data.created} )}`; + }, + + async popup(data, tip) { + const [permission, broadcast_id] = await Promise.all([ + navigator.permissions.query({name: 'clipboard-write'}), + data.getBroadcastID() + ]); + if ( ! broadcast_id ) + return (
+ { this.i18n.t('metadata.uptime-no-id', 'Sorry, we couldn\'t find an archived video for the current broadcast.') } +
); + + const url = `https://www.twitch.tv/videos/${broadcast_id}${data.uptime > 0 ? `?t=${durationForURL(data.uptime)}` : ''}`, + can_copy = permission?.state === 'granted' || permission?.state === 'prompt'; + + const copy = can_copy ? e => { + navigator.clipboard.writeText(url); + e.preventDefault(); + return false; + } : null; + + tip.element.classList.add('tw-balloon--lg'); + + return (
+
+ { this.i18n.t('metadata.uptime.link-to', 'Link to {time}', { + time: duration_to_string(data.uptime, false, false, false, false) + }) } +
+
+ e.target.select()} + /> + {can_copy &&
+ +
+ { this.i18n.t('metadata.uptime.copy', 'Copy to Clipboard') } +
+
} +
+
); } } this.definitions['player-stats'] = { - button: false, + button: true, + inherit: true, refresh() { return this.settings.get('metadata.player-stats') @@ -170,10 +229,10 @@ export default class Metadata extends Module { videoWidth, displayHeight, displayWidth, - fps: (maybe_call(player.getVideoFrameRate, player) || 0).toFixed(2), + fps: Math.floor(maybe_call(player.getVideoFrameRate, player) || 0), hlsLatencyBroadcaster: player.stats?.broadcasterLatency, hlsLatencyEncoder: player.stats?.transcoderLatency, - playbackRate: (maybe_call(player.getVideoBitRate, player) || 0) / 1000, + playbackRate: Math.floor((maybe_call(player.getVideoBitRate, player) || 0) / 1000), skippedFrames: maybe_call(player.getDroppedFrames, player), } } @@ -691,17 +750,8 @@ export default class Metadata extends Module { button = true; let btn, popup; - const border = maybe_call(def.border, this, data); - - /* let cls = maybe_call(def.button, this, data); - - if ( typeof cls !== 'string' ) - cls = cls ? 'tw-border-t tw-border-l tw-border-b ' - - if ( typeof cls !== 'string' ) - cls = cls ? 'ffz-button--hollow' : 'tw-button--text'; - - const fix = cls === 'tw-button--text';*/ + const border = maybe_call(def.border, this, data), + inherit = maybe_call(def.inherit, this, data); if ( typeof icon === 'string' ) icon = ( @@ -709,29 +759,13 @@ export default class Metadata extends Module { ); if ( def.popup && def.click ) { - /*el = ( - {btn = ()} - {popup = ()} - );*/ - el = (
{btn = ()} {popup = (); - /*btn = popup = el = ();*/ - if ( def.click ) btn.addEventListener('click', e => { if ( el._ffz_fading || btn.disabled || btn.classList.contains('disabled') || el.disabled || el.classList.contains('disabled') ) @@ -831,7 +853,7 @@ export default class Metadata extends Module { tooltipClass: 'ffz-metadata-balloon tw-balloon tw-block tw-border tw-elevation-1 tw-border-radius-small tw-c-background-base', // Hide the arrow for now, until we re-do our CSS to make it render correctly. arrowClass: 'tw-balloon__tail tw-overflow-hidden tw-absolute', - arrowInner: 'tw-balloon__tail-symbol tw-border-t tw-border-r tw-border-b tw-border-l tw-border-radius-small tw-c-background-base tw-absolute', + arrowInner: 'tw-balloon__tail-symbol tw-border-t tw-border-r tw-border-b tw-border-l tw-border-radius-small tw-c-background-base tw-absolute', innerClass: 'tw-pd-1', popper: { diff --git a/src/sites/twitch-twilight/modules/channel_bar.jsx b/src/sites/twitch-twilight/modules/channel_bar.jsx index f520be61..755e97ce 100644 --- a/src/sites/twitch-twilight/modules/channel_bar.jsx +++ b/src/sites/twitch-twilight/modules/channel_bar.jsx @@ -105,6 +105,58 @@ export default class ChannelBar extends Module { } + getBroadcastID(inst) { + const current_id = inst.props?.channel?.stream?.id; + if ( current_id === inst._ffz_stream_id ) { + if ( Date.now() - inst._ffz_broadcast_saved < 60000 ) + return Promise.resolve(inst._ffz_broadcast_id); + } + + return new Promise(async (s, f) => { + if ( inst._ffz_broadcast_updating ) + return inst._ffz_broadcast_updating.push([s, f]); + + inst._ffz_broadcast_updating = [[s, f]]; + + let id, err; + + try { + id = await this.twitch_data.getBroadcastID(inst.props.channel.id); + } catch(error) { + id = null; + err = error; + } + + const waiters = inst._ffz_broadcast_updating; + inst._ffz_broadcast_updating = null; + + if ( current_id !== inst.props?.channel?.stream?.id ) { + err = new Error('Outdated'); + inst._ffz_stream_id = null; + inst._ffz_broadcast_saved = 0; + inst._ffz_broadcast_id = null; + + for(const pair of waiters) + pair[1](err); + + return; + } + + inst._ffz_broadcast_id = id; + inst._ffz_broadcast_saved = Date.now(); + inst._ffz_stream_id = current_id; + + if ( err ) { + for(const pair of waiters) + pair[1](err); + } else { + for(const pair of waiters) + pair[0](id); + } + }); + } + + async updateUptime(inst) { const current_id = inst?.props?.channel?.id; if ( current_id === inst._ffz_uptime_id ) { @@ -156,7 +208,8 @@ export default class ChannelBar extends Module { meta: inst._ffz_meta, hosting: false, legacy: true, - _inst: inst + _inst: inst, + getBroadcastID: () => this.getBroadcastID(inst) } for(const key of keys) diff --git a/src/sites/twitch-twilight/modules/player.jsx b/src/sites/twitch-twilight/modules/player.jsx index f60db935..10515c23 100644 --- a/src/sites/twitch-twilight/modules/player.jsx +++ b/src/sites/twitch-twilight/modules/player.jsx @@ -49,6 +49,12 @@ export default class Player extends Module { ['user', 'video', 'user-video', 'user-clip'] ); + this.PlayerSource = this.fine.define( + 'player-source', + n => n.setSrc && n.setInitialPlaybackSettings, + false + ); + // Settings @@ -67,19 +73,19 @@ export default class Player extends Module { } }); - /*this.settings.add('player.button.reset', { + this.settings.add('player.button.reset', { default: true, ui: { path: 'Player > General >> General', title: 'Add a `Reset Player` button to the player controls.', - description: "Double-clicking the Reset Player button destroys and recreates Twitch's player, potentially fixing playback issues without a full page refresh.", + description: "Double-clicking the Reset Player button attempts to reset the Twitch player's internal state, fixing playback issues without a full page refresh.", component: 'setting-check-box' }, changed: () => { for(const inst of this.Player.instances) this.addResetButton(inst); } - });*/ + }); if ( document.pictureInPictureEnabled ) this.settings.add('player.button.pip', { @@ -386,6 +392,9 @@ export default class Player extends Module { if ( ! this._ffzUpdateState ) this._ffzUpdateState = this.ffzUpdateState.bind(this); + if ( ! this._ffzErrorReset ) + this._ffzErrorReset = t.addErrorResetButton.bind(t, this); + const inst = this, old_active = this.setPlayerActive, old_inactive = this.setPlayerInactive; @@ -415,6 +424,7 @@ export default class Player extends Module { if ( events ) { on(events, 'Playing', this._ffzUpdateState); on(events, 'PlayerError', this._ffzUpdateState); + on(events, 'PlayerError', this._ffzErrorReset); on(events, 'Ended', this._ffzUpdateState); on(events, 'Ended', this.ffzOnEnded); on(events, 'Idle', this._ffzUpdateState); @@ -431,6 +441,7 @@ export default class Player extends Module { if ( events && this._ffzUpdateState ) { off(events, 'Playing', this._ffzUpdateState); off(events, 'PlayerError', this._ffzUpdateState); + off(events, 'PlayerError', this._ffzErrorReset); off(events, 'Ended', this._ffzUpdateState); off(events, 'Ended', this.ffzOnEnded); off(events, 'Idle', this._ffzUpdateState); @@ -440,6 +451,7 @@ export default class Player extends Module { this._ffz_state_raf = null; this._ffzUpdateState = null; + this._ffzErrorReset = null; this.ffzOnEnded = null; } @@ -573,9 +585,8 @@ export default class Player extends Module { } }); - this.Player.on('mount', inst => { - this.updateGUI(inst); - }); + this.Player.on('mount', this.updateGUI, this); + this.Player.on('update', this.updateGUI, this); this.Player.on('unmount', inst => { inst.ffzUninstall(); @@ -711,6 +722,7 @@ export default class Player extends Module { updateGUI(inst) { this.addPiPButton(inst); + this.addResetButton(inst); } @@ -753,7 +765,11 @@ export default class Player extends Module { {tip = (); - container.appendChild(cont); + const thing = container.querySelector('button[data-a-target="player-theatre-mode-button"]'); + if ( thing ) { + container.insertBefore(cont, thing.parentElement); + } else + container.appendChild(cont); } else { icon = cont.querySelector('figure'); @@ -792,6 +808,138 @@ export default class Player extends Module { } + addResetButton(inst, tries = 0) { + const outer = inst.props.containerRef || this.fine.getChildNode(inst), + container = outer && outer.querySelector('.player-controls__right-control-group'), + has_reset = this.settings.get('player.button.reset'); + + if ( ! container ) { + if ( ! has_reset ) + return; + + if ( tries < 5 ) + return setTimeout(this.addResetButton.bind(this, inst, (tries || 0) + 1), 250); + + return this.log.warn('Unable to find container element for Reset button.'); + } + + let tip, btn, cont = container.querySelector('.ffz--player-reset'); + if ( ! has_reset ) { + if ( cont ) + cont.remove(); + return; + } + + if ( ! cont ) { + cont = (
+ {btn = ()} + {tip = (); + + const thing = container.querySelector('.ffz--player-pip button') || container.querySelector('button[data-a-target="player-theatre-mode-button"]'); + if ( thing ) { + container.insertBefore(cont, thing.parentElement); + } else + container.appendChild(cont); + + } else { + btn = cont.querySelector('button'); + tip = cont.querySelector('.tw-tooltip'); + } + + btn.setAttribute('aria-label', + tip.textContent = this.i18n.t( + 'player.reset_button', + 'Double-Click to Reset Player' + )); + } + + + addErrorResetButton(inst, tries = 0) { + const outer = inst.props.containerRef || this.fine.getChildNode(inst), + container = outer && outer.querySelector('.content-overlay-gate'), + has_reset = this.settings.get('player.button.reset'); + + if ( ! container ) { + if ( ! has_reset ) + return; + + if ( tries < 2 ) + this.parent.awaitElement( + '.autoplay-vod__content-container button', + this.props.containerRef || t.fine.getChildNode(this), + 1000 + ).then(() => { + this.addErrorResetButton(inst, (tries || 0) + 1); + + }).catch(() => { + this.log.warn('Unable to find container element for Error Reset button.'); + }); + + return; + } + + let tip, btn, cont = container.querySelector('.ffz--player-reset'); + if ( ! has_reset ) { + if ( cont ) + cont.remove(); + return; + } + + if ( ! cont ) { + cont = (
+ {btn = ()} + {tip = (); + + container.appendChild(cont); + + } else { + btn = cont.querySelector('button'); + tip = cont.querySelector('.tw-tooltip'); + } + + btn.setAttribute('aria-label', + tip.textContent = this.i18n.t( + 'player.reset_button', + 'Double-Click to Reset Player' + )); + } + + + resetPlayer(inst) { + const player = inst ? (inst.mediaSinkManager ? inst : inst?.props?.mediaPlayerInstance) : null; + + this.PlayerSource.check(); + for(const inst of this.PlayerSource.instances) { + if ( ! player || player === inst.props?.mediaPlayerInstance ) + inst.setSrc({isNewMediaPlayerInstance: false}); + } + } + + tryTheatreMode(inst) { if ( ! this.settings.get('player.theatre.auto-enter') ) return; diff --git a/src/utilities/compat/fine.js b/src/utilities/compat/fine.js index 36fe350a..7de576e2 100644 --- a/src/utilities/compat/fine.js +++ b/src/utilities/compat/fine.js @@ -247,9 +247,9 @@ export default class Fine extends Module { } - findAllMatching(node, criteria, max_depth=15, parents=false, depth=0, traverse_roots=true) { - const matches = new Set, - crit = n => ! matches.has(n) && criteria(n); + findAllMatching(node, criteria, max_depth=15, single_class = true, parents=false, depth=0, traverse_roots=true) { + const matches = new Set; + let crit = n => ! matches.has(n) && criteria(n); while(true) { const match = parents ? @@ -259,6 +259,11 @@ export default class Fine extends Module { if ( ! match ) break; + if ( single_class && ! matches.size ) { + const klass = match.constructor; + crit = n => ! matches.has(n) && (n instanceof klass) && criteria(n); + } + matches.add(match); } @@ -377,7 +382,7 @@ export default class Fine extends Module { wrapper._set(data.cls, data.instances); this._known_classes.set(data.cls, wrapper); - } else { + } else if ( routes !== false ) { this._waiting.push(wrapper); this._updateLiveWaiting(); } @@ -517,6 +522,17 @@ export class FineWrapper extends EventEmitter { return Array.from(this.instances); } + check(node = null, max_depth = 1000) { + if ( this._class ) + return; + + const instances = this.fine.findAllMatching(node, this.criteria, max_depth); + if ( instances.size ) { + const insts = Array.from(instances); + this._set(insts[0].constructor, insts); + } + } + ready(fn) { if ( this._class ) fn(this._class, this.instances); diff --git a/src/utilities/data/broadcast-id.gql b/src/utilities/data/broadcast-id.gql new file mode 100644 index 00000000..be2ca61b --- /dev/null +++ b/src/utilities/data/broadcast-id.gql @@ -0,0 +1,11 @@ +query FFZ_BroadcastID($id: ID, $login: String) { + user(id: $id, login: $login) { + id + stream { + id + archiveVideo { + id + } + } + } +} \ No newline at end of file diff --git a/src/utilities/ffz-icons.js b/src/utilities/ffz-icons.js index f4c51905..aca98d45 100644 --- a/src/utilities/ffz-icons.js +++ b/src/utilities/ffz-icons.js @@ -82,5 +82,6 @@ export default [ "clip", "youtube-play", "minus", - "left-open" + "left-open", + "docs" ]; \ No newline at end of file diff --git a/src/utilities/time.js b/src/utilities/time.js index 7f955be4..ab8e14c0 100644 --- a/src/utilities/time.js +++ b/src/utilities/time.js @@ -39,4 +39,15 @@ export function print_duration(seconds) { seconds %= 60; return `${hours > 0 ? `${hours}:${minutes < 10 ? '0' : ''}` : ''}${minutes}:${seconds < 10 ? '0' : ''}${seconds}`; +} + + +export function durationForURL(elapsed) { + const seconds = elapsed % 60; + let minutes = Math.floor(elapsed / 60); + const hours = Math.floor(minutes / 60); + + minutes = minutes % 60; + + return `${hours > 0 ? `${hours}h` : ''}${minutes > 0 ? `${minutes}m` : ''}${seconds > 0 ? `${seconds}s` : ''}`; } \ No newline at end of file diff --git a/src/utilities/twitch-data.js b/src/utilities/twitch-data.js index 2981bf04..311a92f5 100644 --- a/src/utilities/twitch-data.js +++ b/src/utilities/twitch-data.js @@ -169,6 +169,23 @@ export default class TwitchData extends Module { } + // ======================================================================== + // Broadcast ID + // ======================================================================== + + async getBroadcastID(id, login) { + const data = await this.queryApollo({ + query: require('./data/broadcast-id.gql'), + variables: { + id, + login + } + }); + + return get('data.user.stream.archiveVideo.id', data); + } + + // ======================================================================== // Stream Up-Type (Uptime and Type, for Directory Purposes) // ======================================================================== diff --git a/styles/fontello/ffz-fontello-codes.scss b/styles/fontello/ffz-fontello-codes.scss index 9b029529..c9d47039 100644 --- a/styles/fontello/ffz-fontello-codes.scss +++ b/styles/fontello/ffz-fontello-codes.scss @@ -57,6 +57,7 @@ .ffz-i-link-ext:before { content: '\f08e'; } /* '' */ .ffz-i-twitter:before { content: '\f099'; } /* '' */ .ffz-i-github:before { content: '\f09b'; } /* '' */ +.ffz-i-docs:before { content: '\f0c5'; } /* '' */ .ffz-i-sort-down:before { content: '\f0dd'; } /* '' */ .ffz-i-sort-up:before { content: '\f0de'; } /* '' */ .ffz-i-gauge:before { content: '\f0e4'; } /* '' */ diff --git a/styles/fontello/ffz-fontello-embedded.scss b/styles/fontello/ffz-fontello-embedded.scss index 6bf132cc..c4dbd0cd 100644 --- a/styles/fontello/ffz-fontello-embedded.scss +++ b/styles/fontello/ffz-fontello-embedded.scss @@ -1,15 +1,15 @@ @font-face { font-family: 'ffz-fontello'; - src: url('../font/ffz-fontello.eot?73160171'); - src: url('../font/ffz-fontello.eot?73160171#iefix') format('embedded-opentype'), - url('../font/ffz-fontello.svg?73160171#ffz-fontello') format('svg'); + src: url('../font/ffz-fontello.eot?82651439'); + src: url('../font/ffz-fontello.eot?82651439#iefix') format('embedded-opentype'), + url('../font/ffz-fontello.svg?82651439#ffz-fontello') format('svg'); font-weight: normal; font-style: normal; } @font-face { font-family: 'ffz-fontello'; - src: url('data:application/octet-stream;base64,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') format('woff'), - url('data:application/octet-stream;base64,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') format('truetype'); + src: url('data:application/octet-stream;base64,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') format('woff'), + url('data:application/octet-stream;base64,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') format('truetype'); } /* Chrome hack: SVG is rendered more smooth in Windozze. 100% magic, uncomment if you need it. */ /* Note, that will break hinting! In other OS-es font will be not as sharp as it could be */ @@ -17,7 +17,7 @@ @media screen and (-webkit-min-device-pixel-ratio:0) { @font-face { font-family: 'ffz-fontello'; - src: url('../font/ffz-fontello.svg?73160171#ffz-fontello') format('svg'); + src: url('../font/ffz-fontello.svg?82651439#ffz-fontello') format('svg'); } } */ @@ -110,6 +110,7 @@ .ffz-i-link-ext:before { content: '\f08e'; } /* '' */ .ffz-i-twitter:before { content: '\f099'; } /* '' */ .ffz-i-github:before { content: '\f09b'; } /* '' */ +.ffz-i-docs:before { content: '\f0c5'; } /* '' */ .ffz-i-sort-down:before { content: '\f0dd'; } /* '' */ .ffz-i-sort-up:before { content: '\f0de'; } /* '' */ .ffz-i-gauge:before { content: '\f0e4'; } /* '' */ diff --git a/styles/fontello/ffz-fontello-ie7-codes.scss b/styles/fontello/ffz-fontello-ie7-codes.scss index 1b492207..62372c64 100644 --- a/styles/fontello/ffz-fontello-ie7-codes.scss +++ b/styles/fontello/ffz-fontello-ie7-codes.scss @@ -57,6 +57,7 @@ .ffz-i-link-ext { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } .ffz-i-twitter { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } .ffz-i-github { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } +.ffz-i-docs { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } .ffz-i-sort-down { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } .ffz-i-sort-up { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } .ffz-i-gauge { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } diff --git a/styles/fontello/ffz-fontello-ie7.scss b/styles/fontello/ffz-fontello-ie7.scss index 9ff40e65..997c0d21 100644 --- a/styles/fontello/ffz-fontello-ie7.scss +++ b/styles/fontello/ffz-fontello-ie7.scss @@ -68,6 +68,7 @@ .ffz-i-link-ext { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } .ffz-i-twitter { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } .ffz-i-github { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } +.ffz-i-docs { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } .ffz-i-sort-down { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } .ffz-i-sort-up { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } .ffz-i-gauge { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } diff --git a/styles/fontello/ffz-fontello.scss b/styles/fontello/ffz-fontello.scss index 2406bb0a..49412cb3 100644 --- a/styles/fontello/ffz-fontello.scss +++ b/styles/fontello/ffz-fontello.scss @@ -1,11 +1,11 @@ @font-face { font-family: 'ffz-fontello'; - src: url('../font/ffz-fontello.eot?60288408'); - src: url('../font/ffz-fontello.eot?60288408#iefix') format('embedded-opentype'), - url('../font/ffz-fontello.woff2?60288408') format('woff2'), - url('../font/ffz-fontello.woff?60288408') format('woff'), - url('../font/ffz-fontello.ttf?60288408') format('truetype'), - url('../font/ffz-fontello.svg?60288408#ffz-fontello') format('svg'); + src: url('../font/ffz-fontello.eot?36275888'); + src: url('../font/ffz-fontello.eot?36275888#iefix') format('embedded-opentype'), + url('../font/ffz-fontello.woff2?36275888') format('woff2'), + url('../font/ffz-fontello.woff?36275888') format('woff'), + url('../font/ffz-fontello.ttf?36275888') format('truetype'), + url('../font/ffz-fontello.svg?36275888#ffz-fontello') format('svg'); font-weight: normal; font-style: normal; } @@ -15,7 +15,7 @@ @media screen and (-webkit-min-device-pixel-ratio:0) { @font-face { font-family: 'ffz-fontello'; - src: url('../font/ffz-fontello.svg?60288408#ffz-fontello') format('svg'); + src: url('../font/ffz-fontello.svg?36275888#ffz-fontello') format('svg'); } } */ @@ -113,6 +113,7 @@ .ffz-i-link-ext:before { content: '\f08e'; } /* '' */ .ffz-i-twitter:before { content: '\f099'; } /* '' */ .ffz-i-github:before { content: '\f09b'; } /* '' */ +.ffz-i-docs:before { content: '\f0c5'; } /* '' */ .ffz-i-sort-down:before { content: '\f0dd'; } /* '' */ .ffz-i-sort-up:before { content: '\f0de'; } /* '' */ .ffz-i-gauge:before { content: '\f0e4'; } /* '' */ diff --git a/styles/main.scss b/styles/main.scss index 6ceeb3bb..594bb5b8 100644 --- a/styles/main.scss +++ b/styles/main.scss @@ -15,4 +15,16 @@ .ffz-i-zreknarf.loading { animation: ffz-rotateplane 1.2s infinite linear; +} + +.ffz-c-text-inherit { + color: inherit !important; +} + +.ffz-mg-r--05 { + margin-right: -0.5rem !important; +} + +.ffz-mg-l--05 { + margin-left: -0.5rem !important; } \ No newline at end of file