ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/command.C
(Generate patch)

Comparing rxvt-unicode/src/command.C (file contents):
Revision 1.97 by root, Mon Jul 26 18:01:19 2004 UTC vs.
Revision 1.116 by root, Wed Aug 4 03:29:28 2004 UTC

… …
675 IMSendSpot (); 675 IMSendSpot ();
676#endif 676#endif
677 } 677 }
678 678
679 display->flush (); 679 display->flush ();
680
681 flush_ev.stop ();
680} 682}
681 683
682void 684void
683rxvt_term::check_cb (check_watcher &w) 685rxvt_term::check_cb (check_watcher &w)
684{ 686{
685 SET_R (this); 687 SET_R (this);
686 SET_LOCALE (locale); 688 SET_LOCALE (locale);
687 689
690 display->flush ();
691
692 if (!flush_ev.active)
693 flush_ev.start (NOW + 0.01);
694}
695
696void
697rxvt_term::flush_cb (time_watcher &w)
698{
699 SET_R (this);
700 SET_LOCALE (locale);
701
702 refresh_limit = 1;
703 refresh_count = 0;
688 flush (); 704 flush ();
689} 705}
690 706
691#ifdef CURSOR_BLINK 707#ifdef CURSOR_BLINK
692void 708void
… …
796 while (pty_fill ()) 812 while (pty_fill ())
797 if (cmd_parse ()) 813 if (cmd_parse ())
798 break; 814 break;
799} 815}
800 816
801#ifdef POINTER_BLANK
802void 817void
803rxvt_term::pointer_unblank () 818rxvt_term::pointer_unblank ()
804{ 819{
805 XDefineCursor (display->display, TermWin.vt, TermWin_cursor); 820 XDefineCursor (display->display, TermWin.vt, TermWin_cursor);
806 recolour_cursor (); 821 recolour_cursor ();
807 822
823#ifdef POINTER_BLANK
808 hidden_pointer = 0; 824 hidden_pointer = 0;
809 825
810 if (Options & Opt_pointerBlank) 826 if (Options & Opt_pointerBlank)
811 pointer_ev.start (NOW + pointerBlankDelay); 827 pointer_ev.start (NOW + pointerBlankDelay);
828#endif
812} 829}
813 830
831#ifdef POINTER_BLANK
814void 832void
815rxvt_term::pointer_blank () 833rxvt_term::pointer_blank ()
816{ 834{
817 if (! (Options & Opt_pointerBlank)) 835 if (! (Options & Opt_pointerBlank))
818 return; 836 return;
… …
1072 } 1090 }
1073#endif /* OFFIX_DND */ 1091#endif /* OFFIX_DND */
1074 break; 1092 break;
1075 1093
1076 case MappingNotify: 1094 case MappingNotify:
1077 XRefreshKeyboardMapping (& (ev.xmapping)); 1095 XRefreshKeyboardMapping (&ev.xmapping);
1078 break; 1096 break;
1079 1097
1080 /* 1098 /*
1081 * XXX: this is not the _current_ arrangement 1099 * XXX: this is not the _current_ arrangement
1082 * Here's my conclusion: 1100 * Here's my conclusion:
… …
1113#endif 1131#endif
1114#ifdef CURSOR_BLINK 1132#ifdef CURSOR_BLINK
1115 if (Options & Opt_cursorBlink) 1133 if (Options & Opt_cursorBlink)
1116 cursor_blink_ev.start (NOW + BLINK_INTERVAL); 1134 cursor_blink_ev.start (NOW + BLINK_INTERVAL);
1117#endif 1135#endif
1136#ifdef OFF_FOCUS_FADING
1137 if (rs[Rs_fade])
1138 {
1139 PixColors = PixColorsFocused;
1140 set_colorfgbg ();
1141 scr_clear ();
1142 scr_touch (true);
1143 }
1144#endif
1118 1145
1119 } 1146 }
1120 break; 1147 break;
1121 1148
1122 case FocusOut: 1149 case FocusOut:
… …
1131#ifdef CURSOR_BLINK 1158#ifdef CURSOR_BLINK
1132 if (Options & Opt_cursorBlink) 1159 if (Options & Opt_cursorBlink)
1133 cursor_blink_ev.stop (); 1160 cursor_blink_ev.stop ();
1134 hidden_cursor = 0; 1161 hidden_cursor = 0;
1135#endif 1162#endif
1163#ifdef OFF_FOCUS_FADING
1164 if (rs[Rs_fade])
1165 {
1166 PixColors = PixColorsUnFocused;
1167 set_colorfgbg ();
1168 scr_clear ();
1169 scr_touch (true);
1170 }
1171#endif
1136 1172
1137 } 1173 }
1138 break; 1174 break;
1139 1175
1140 case ConfigureNotify: 1176 case ConfigureNotify:
… …
1149 D_SIZE ((stderr, "Size: ConfigureNotify: %4d x %4d", width, height)); 1185 D_SIZE ((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));
1150 } 1186 }
1151 while (XCheckTypedWindowEvent (display->display, ev.xconfigure.window, ConfigureNotify, &ev)); 1187 while (XCheckTypedWindowEvent (display->display, ev.xconfigure.window, ConfigureNotify, &ev));
1152 1188
1153 if (szHint.width != width || szHint.height != height) 1189 if (szHint.width != width || szHint.height != height)
1154 {
1155 D_SIZE ((stderr, "Size: Resizing from: %4d x %4d", szHint.width, szHint.height));
1156 resize_all_windows (width, height, 1); 1190 resize_all_windows (width, height, 1);
1157 } 1191
1158#ifdef DEBUG_SIZE
1159 else
1160 {
1161 D_SIZE ((stderr, "Size: Not resizing"));
1162 }
1163#endif
1164#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */ 1192#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */
1165 if (Options & Opt_transparent) 1193 if (Options & Opt_transparent)
1166 { 1194 {
1167 check_our_parents (); 1195 check_our_parents ();
1168 if (am_transparent) 1196 if (am_transparent)
… …
1208 1236
1209 case GraphicsExpose: 1237 case GraphicsExpose:
1210 case Expose: 1238 case Expose:
1211 if (ev.xany.window == TermWin.vt) 1239 if (ev.xany.window == TermWin.vt)
1212 { 1240 {
1213#ifdef NO_SLOW_LINK_SUPPORT 1241 do
1214 scr_expose (ev.xexpose.x, ev.xexpose.y, 1242 scr_expose (ev.xexpose.x, ev.xexpose.y,
1215 ev.xexpose.width, ev.xexpose.height, False); 1243 ev.xexpose.width, ev.xexpose.height, False);
1216#else 1244 while (XCheckTypedWindowEvent (display->display, TermWin.vt, ev.xany.type, &ev));
1217 // I don't understand this, so I changed it :) 1245
1246 ev.xany.type = ev.xany.type == Expose ? GraphicsExpose : Expose;
1247
1248 while (XCheckTypedWindowEvent (display->display, TermWin.vt, ev.xany.type, &ev))
1218 scr_expose (ev.xexpose.x, ev.xexpose.y, 1249 scr_expose (ev.xexpose.x, ev.xexpose.y,
1219 ev.xexpose.width, ev.xexpose.height, False); 1250 ev.xexpose.width, ev.xexpose.height, False);
1220 //scr_expose (ev.xexpose.x, 0, 1251
1221 // ev.xexpose.width, TermWin.height, False); 1252 scr_refresh (refresh_type);
1222#endif
1223 want_refresh = 1;
1224 } 1253 }
1225 else 1254 else
1226 { 1255 {
1227 XEvent unused_event; 1256 XEvent unused_event;
1228 1257
… …
1237 scrollbar_show (0); 1266 scrollbar_show (0);
1238 } 1267 }
1239#ifdef MENUBAR 1268#ifdef MENUBAR
1240 if (menubar_visible () && isMenuBarWindow (ev.xany.window)) 1269 if (menubar_visible () && isMenuBarWindow (ev.xany.window))
1241 menubar_expose (); 1270 menubar_expose ();
1271#endif
1272
1273#ifdef TRANSPARENT
1274 if (am_transparent && ev.xany.window == TermWin.parent[0])
1275 XClearWindow (display->display, ev.xany.window);
1242#endif 1276#endif
1243 } 1277 }
1244 break; 1278 break;
1245 1279
1246 case MotionNotify: 1280 case MotionNotify:
… …
1708 1742
1709# ifdef MOUSE_SLIP_WHEELING 1743# ifdef MOUSE_SLIP_WHEELING
1710 if (ev.state & ControlMask) 1744 if (ev.state & ControlMask)
1711 { 1745 {
1712 mouse_slip_wheel_speed += v ? -1 : 1; 1746 mouse_slip_wheel_speed += v ? -1 : 1;
1747 if (mouse_slip_wheel_speed < -TermWin.nrow) mouse_slip_wheel_speed = -TermWin.nrow;
1748 if (mouse_slip_wheel_speed > +TermWin.nrow) mouse_slip_wheel_speed = +TermWin.nrow;
1749
1750 if (slip_wheel_ev.at < NOW)
1713 slip_wheel_ev.start (NOW + SCROLLBAR_CONTINUOUS_DELAY); 1751 slip_wheel_ev.at = NOW + SCROLLBAR_CONTINUOUS_DELAY;
1752
1753 slip_wheel_ev.start ();
1714 } 1754 }
1755 else
1756 {
1715# endif 1757# endif
1716# ifdef JUMP_MOUSE_WHEEL 1758# ifdef JUMP_MOUSE_WHEEL
1717 scr_page (v, i);
1718 scr_refresh (SMOOTH_REFRESH);
1719 scrollbar_show (1);
1720# else
1721 while (i--)
1722 {
1723 scr_page (v, 1); 1759 scr_page (v, i);
1724 scr_refresh (SMOOTH_REFRESH); 1760 scr_refresh (SMOOTH_REFRESH);
1725 scrollbar_show (1); 1761 scrollbar_show (1);
1762# else
1763 while (i--)
1764 {
1765 scr_page (v, 1);
1766 scr_refresh (SMOOTH_REFRESH);
1767 scrollbar_show (1);
1768 }
1769# endif
1770# ifdef MOUSE_SLIP_WHEELING
1726 } 1771 }
1727# endif 1772#endif
1728
1729 } 1773 }
1730 break; 1774 break;
1731#endif 1775#endif
1732
1733 } 1776 }
1734 } 1777 }
1735#ifdef MENUBAR 1778#ifdef MENUBAR
1736 else if (isMenuBarWindow (ev.window)) 1779 else if (isMenuBarWindow (ev.window))
1737 menubar_control (ev); 1780 menubar_control (ev);
1738#endif 1781#endif
1739} 1782}
1740 1783
1741#ifdef TRANSPARENT 1784#ifdef TRANSPARENT
1742#if TINTING 1785#if TINTING
1743/* shading taken from eterm-0.9.2 */ 1786/* taken from aterm-0.4.2 */
1744/* RGB 15 */
1745 1787
1746static void 1788typedef uint32_t RUINT32T;
1747shade_ximage_15(void *data, int bpl, int w, int h, int rm, int gm, int bm)
1748{
1749 unsigned char *ptr;
1750 int x, y;
1751 1789
1752 ptr = (unsigned char *)data + (w * sizeof(uint16_t)); 1790void ShadeXImage(rxvt_display *display, XImage* srcImage, int shade, int rm, int gm, int bm)
1753 if ((rm <= 256) && (gm <= 256) && (bm <= 256)) { 1791{
1754 /* No saturation */ 1792 int sh_r, sh_g, sh_b;
1755 for (y = h; --y >= 0;) { 1793 RUINT32T mask_r, mask_g, mask_b;
1756 for (x = -w; x < 0; x++) { 1794 RUINT32T *lookup, *lookup_r, *lookup_g, *lookup_b;
1757 int r, g, b; 1795 unsigned int lower_lim_r, lower_lim_g, lower_lim_b;
1796 unsigned int upper_lim_r, upper_lim_g, upper_lim_b;
1797 int i;
1758 1798
1759 b = ((uint16_t *) ptr)[x]; 1799 Visual* visual = display->visual;
1760 r = (b & 0x7c00) * rm; 1800
1761 g = (b & 0x3e0) * gm; 1801 if( visual->c_class != TrueColor || srcImage->format != ZPixmap ) return ;
1762 b = (b & 0x1f) * bm; 1802
1763 ((uint16_t *) ptr)[x] = ((r >> 8) & 0x7c00) 1803 /* for convenience */
1764 | ((g >> 8) & 0x3e0) 1804 mask_r = visual->red_mask;
1765 | ((b >> 8) & 0x1f); 1805 mask_g = visual->green_mask;
1766 } 1806 mask_b = visual->blue_mask;
1767 ptr += bpl; 1807
1768 } 1808 /* boring lookup table pre-initialization */
1809 switch (srcImage->bits_per_pixel) {
1810 case 15:
1811 if ((mask_r != 0x7c00) ||
1812 (mask_g != 0x03e0) ||
1813 (mask_b != 0x001f))
1814 return;
1815 lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+32+32));
1816 lookup_r = lookup;
1817 lookup_g = lookup+32;
1818 lookup_b = lookup+32+32;
1819 sh_r = 10;
1820 sh_g = 5;
1821 sh_b = 0;
1822 break;
1823 case 16:
1824 if ((mask_r != 0xf800) ||
1825 (mask_g != 0x07e0) ||
1826 (mask_b != 0x001f))
1827 return;
1828 lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+64+32));
1829 lookup_r = lookup;
1830 lookup_g = lookup+32;
1831 lookup_b = lookup+32+64;
1832 sh_r = 11;
1833 sh_g = 5;
1834 sh_b = 0;
1835 break;
1836 case 24:
1837 if ((mask_r != 0xff0000) ||
1838 (mask_g != 0x00ff00) ||
1839 (mask_b != 0x0000ff))
1840 return;
1841 lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));
1842 lookup_r = lookup;
1843 lookup_g = lookup+256;
1844 lookup_b = lookup+256+256;
1845 sh_r = 16;
1846 sh_g = 8;
1847 sh_b = 0;
1848 break;
1849 case 32:
1850 if ((mask_r != 0xff0000) ||
1851 (mask_g != 0x00ff00) ||
1852 (mask_b != 0x0000ff))
1853 return;
1854 lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));
1855 lookup_r = lookup;
1856 lookup_g = lookup+256;
1857 lookup_b = lookup+256+256;
1858 sh_r = 16;
1859 sh_g = 8;
1860 sh_b = 0;
1861 break;
1862 default:
1863 return; /* we do not support this color depth */
1864 }
1865
1866 /* prepare limits for color transformation (each channel is handled separately) */
1867 if (shade < 0) {
1868 shade = -shade;
1869 if (shade < 0) shade = 0;
1870 if (shade > 100) shade = 100;
1871
1872 lower_lim_r = 65535-rm;
1873 lower_lim_g = 65535-gm;
1874 lower_lim_b = 65535-bm;
1875
1876 lower_lim_r = 65535-(unsigned int)(((RUINT32T)lower_lim_r)*((RUINT32T)shade)/100);
1877 lower_lim_g = 65535-(unsigned int)(((RUINT32T)lower_lim_g)*((RUINT32T)shade)/100);
1878 lower_lim_b = 65535-(unsigned int)(((RUINT32T)lower_lim_b)*((RUINT32T)shade)/100);
1879
1880 upper_lim_r = upper_lim_g = upper_lim_b = 65535;
1769 } else { 1881 } else {
1770 for (y = h; --y >= 0;) { 1882 if (shade < 0) shade = 0;
1771 for (x = -w; x < 0; x++) { 1883 if (shade > 100) shade = 100;
1772 int r, g, b;
1773 1884
1774 b = ((uint16_t *) ptr)[x]; 1885 lower_lim_r = lower_lim_g = lower_lim_b = 0;
1775 r = (b & 0x7c00) * rm; 1886
1776 g = (b & 0x3e0) * gm; 1887 upper_lim_r = (unsigned int)((((RUINT32T)rm)*((RUINT32T)shade))/100);
1777 b = (b & 0x1f) * bm; 1888 upper_lim_g = (unsigned int)((((RUINT32T)gm)*((RUINT32T)shade))/100);
1778 r |= (!(r >> 15) - 1); 1889 upper_lim_b = (unsigned int)((((RUINT32T)bm)*((RUINT32T)shade))/100);
1779 g |= (!(g >> 10) - 1); 1890 }
1780 b |= (!(b >> 5) - 1); 1891
1781 ((uint16_t *) ptr)[x] = ((r >> 8) & 0x7c00) 1892 /* switch red and blue bytes if necessary, we need it for some weird XServers like XFree86 3.3.3.1 */
1782 | ((g >> 8) & 0x3e0) 1893 if ((srcImage->bits_per_pixel == 24) && (mask_r >= 0xFF0000 ))
1783 | ((b >> 8) & 0x1f); 1894 {
1784 } 1895 unsigned int tmp;
1785 ptr += bpl; 1896
1897 tmp = lower_lim_r;
1898 lower_lim_r = lower_lim_b;
1899 lower_lim_b = tmp;
1900
1901 tmp = upper_lim_r;
1902 upper_lim_r = upper_lim_b;
1903 upper_lim_b = tmp;
1904 }
1905
1906 /* fill our lookup tables */
1907 for (i = 0; i <= mask_r>>sh_r; i++)
1908 {
1909 RUINT32T tmp;
1910 tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_r-lower_lim_r));
1911 tmp += ((RUINT32T)(mask_r>>sh_r))*((RUINT32T)lower_lim_r);
1912 lookup_r[i] = (tmp/65535)<<sh_r;
1913 }
1914 for (i = 0; i <= mask_g>>sh_g; i++)
1915 {
1916 RUINT32T tmp;
1917 tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_g-lower_lim_g));
1918 tmp += ((RUINT32T)(mask_g>>sh_g))*((RUINT32T)lower_lim_g);
1919 lookup_g[i] = (tmp/65535)<<sh_g;
1920 }
1921 for (i = 0; i <= mask_b>>sh_b; i++)
1922 {
1923 RUINT32T tmp;
1924 tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_b-lower_lim_b));
1925 tmp += ((RUINT32T)(mask_b>>sh_b))*((RUINT32T)lower_lim_b);
1926 lookup_b[i] = (tmp/65535)<<sh_b;
1927 }
1928
1929 /* apply table to input image (replacing colors by newly calculated ones) */
1930 switch (srcImage->bits_per_pixel)
1931 {
1932 case 15:
1933 {
1934 unsigned short *p1, *pf, *p, *pl;
1935 p1 = (unsigned short *) srcImage->data;
1936 pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1937 while (p1 < pf)
1938 {
1939 p = p1;
1940 pl = p1 + srcImage->width;
1941 for (; p < pl; p++)
1786 } 1942 {
1943 *p = lookup_r[(*p & 0x7c00)>>10] |
1944 lookup_g[(*p & 0x03e0)>> 5] |
1945 lookup_b[(*p & 0x001f)];
1946 }
1947 p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
1787 } 1948 }
1788} 1949 break;
1789 1950 }
1790/* RGB 16 */ 1951 case 16:
1791static void 1952 {
1792shade_ximage_16(void *data, int bpl, int w, int h, int rm, int gm, int bm) 1953 unsigned short *p1, *pf, *p, *pl;
1793{ 1954 p1 = (unsigned short *) srcImage->data;
1794 unsigned char *ptr; 1955 pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1795 int x, y; 1956 while (p1 < pf)
1796 1957 {
1797 ptr = (unsigned char *)data + (w * sizeof(uint16_t)); 1958 p = p1;
1798 if ((rm <= 256) && (gm <= 256) && (bm <= 256)) { 1959 pl = p1 + srcImage->width;
1799 /* No saturation */ 1960 for (; p < pl; p++)
1800 for (y = h; --y >= 0;) {
1801 for (x = -w; x < 0; x++) {
1802 int r, g, b;
1803
1804 b = ((uint16_t *) ptr)[x];
1805 r = (b & 0xf800) * rm;
1806 g = (b & 0x7e0) * gm;
1807 b = (b & 0x1f) * bm;
1808 ((uint16_t *) ptr)[x] = ((r >> 8) & 0xf800)
1809 | ((g >> 8) & 0x7e0)
1810 | ((b >> 8) & 0x1f);
1811 }
1812 ptr += bpl;
1813 } 1961 {
1814 } else { 1962 *p = lookup_r[(*p & 0xf800)>>11] |
1815 for (y = h; --y >= 0;) { 1963 lookup_g[(*p & 0x07e0)>> 5] |
1816 for (x = -w; x < 0; x++) { 1964 lookup_b[(*p & 0x001f)];
1817 int r, g, b;
1818
1819 b = ((uint16_t *) ptr)[x];
1820 r = (b & 0xf800) * rm;
1821 g = (b & 0x7e0) * gm;
1822 b = (b & 0x1f) * bm;
1823 r |= (!(r >> 16) - 1);
1824 g |= (!(g >> 11) - 1);
1825 b |= (!(b >> 5) - 1);
1826 ((uint16_t *) ptr)[x] = ((r >> 8) & 0xf800)
1827 | ((g >> 8) & 0x7e0)
1828 | ((b >> 8) & 0x1f);
1829 } 1965 }
1830 ptr += bpl; 1966 p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
1967 }
1968 break;
1969 }
1970 case 24:
1971 {
1972 unsigned char *p1, *pf, *p, *pl;
1973 p1 = (unsigned char *) srcImage->data;
1974 pf = (unsigned char *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1975 while (p1 < pf)
1976 {
1977 p = p1;
1978 pl = p1 + srcImage->width * 3;
1979 for (; p < pl; p += 3)
1831 } 1980 {
1981 p[0] = lookup_r[(p[0] & 0xff0000)>>16];
1982 p[1] = lookup_r[(p[1] & 0x00ff00)>> 8];
1983 p[2] = lookup_r[(p[2] & 0x0000ff)];
1984 }
1985 p1 = (unsigned char *) ((char *) p1 + srcImage->bytes_per_line);
1832 } 1986 }
1833} 1987 break;
1988 }
1989 case 32:
1990 {
1991 RUINT32T *p1, *pf, *p, *pl;
1992 p1 = (RUINT32T *) srcImage->data;
1993 pf = (RUINT32T *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1834 1994
1835/* RGB 24 */ 1995 while (p1 < pf)
1836static void 1996 {
1837shade_ximage_24(void *data, int bpl, int w, int h, int rm, int gm, int bm) 1997 p = p1;
1838{ 1998 pl = p1 + srcImage->width;
1839 unsigned char *ptr; 1999 for (; p < pl; p++)
1840 int x, y;
1841
1842 ptr = (unsigned char *)data + (w * 3);
1843 if ((rm <= 256) && (gm <= 256) && (bm <= 256)) {
1844 /* No saturation */
1845 for (y = h; --y >= 0;) {
1846 for (x = -(w * 3); x < 0; x += 3) {
1847 int r, g, b;
1848
1849 if (byteorder.big_endian()) {
1850 r = (ptr[x + 0] * rm) >> 8;
1851 g = (ptr[x + 1] * gm) >> 8;
1852 b = (ptr[x + 2] * bm) >> 8;
1853 ptr[x + 0] = r;
1854 ptr[x + 1] = g;
1855 ptr[x + 2] = b;
1856 } else {
1857 r = (ptr[x + 2] * rm) >> 8;
1858 g = (ptr[x + 1] * gm) >> 8;
1859 b = (ptr[x + 0] * bm) >> 8;
1860 ptr[x + 2] = r;
1861 ptr[x + 1] = g;
1862 ptr[x + 0] = b;
1863 }
1864 }
1865 ptr += bpl;
1866 } 2000 {
1867 } else { 2001 *p = lookup_r[(*p & 0xff0000)>>16] |
1868 for (y = h; --y >= 0;) { 2002 lookup_g[(*p & 0x00ff00)>> 8] |
1869 for (x = -(w * 3); x < 0; x += 3) { 2003 lookup_b[(*p & 0x0000ff)] |
1870 int r, g, b; 2004 (*p & ~0xffffff);
1871
1872 if (byteorder.big_endian()) {
1873 r = (ptr[x + 0] * rm) >> 8;
1874 g = (ptr[x + 1] * gm) >> 8;
1875 b = (ptr[x + 2] * bm) >> 8;
1876
1877 r |= (!(r >> 8) - 1);
1878 g |= (!(g >> 8) - 1);
1879 b |= (!(b >> 8) - 1);
1880
1881 ptr[x + 0] = r;
1882 ptr[x + 1] = g;
1883 ptr[x + 2] = b;
1884 } else {
1885 r = (ptr[x + 2] * rm) >> 8;
1886 g = (ptr[x + 1] * gm) >> 8;
1887 b = (ptr[x + 0] * bm) >> 8;
1888
1889 r |= (!(r >> 8) - 1);
1890 g |= (!(g >> 8) - 1);
1891 b |= (!(b >> 8) - 1);
1892
1893 ptr[x + 2] = r;
1894 ptr[x + 1] = g;
1895 ptr[x + 0] = b;
1896 }
1897 } 2005 }
1898 ptr += bpl; 2006 p1 = (RUINT32T *) ((char *) p1 + srcImage->bytes_per_line);
1899 } 2007 }
2008 break;
2009 }
1900 } 2010 }
1901}
1902 2011
1903/* RGB 32 */ 2012 free (lookup);
1904static void
1905shade_ximage_32(void *data, int bpl, int w, int h, int rm, int gm, int bm)
1906{
1907 unsigned char *ptr;
1908 int x, y;
1909
1910 ptr = (unsigned char *)data + (w * 4);
1911 if ((rm <= 256) && (gm <= 256) && (bm <= 256)) {
1912 /* No saturation */
1913 for (y = h; --y >= 0;) {
1914 if (byteorder.big_endian()) {
1915 for (x = -(w * 4); x < 0; x += 4) {
1916 int r, g, b;
1917
1918 r = (ptr[x + 1] * rm) >> 8;
1919 g = (ptr[x + 2] * gm) >> 8;
1920 b = (ptr[x + 3] * bm) >> 8;
1921 ptr[x + 1] = r;
1922 ptr[x + 2] = g;
1923 ptr[x + 3] = b;
1924 }
1925 } else {
1926 for (x = -(w * 4); x < 0; x += 4) {
1927 int r, g, b;
1928
1929 r = (ptr[x + 2] * rm) >> 8;
1930 g = (ptr[x + 1] * gm) >> 8;
1931 b = (ptr[x + 0] * bm) >> 8;
1932 ptr[x + 2] = r;
1933 ptr[x + 1] = g;
1934 ptr[x + 0] = b;
1935 }
1936 }
1937 ptr += bpl;
1938 }
1939 } else {
1940 for (y = h; --y >= 0;) {
1941 for (x = -(w * 4); x < 0; x += 4) {
1942 int r, g, b;
1943
1944 if (byteorder.big_endian()) {
1945 r = (ptr[x + 1] * rm) >> 8;
1946 g = (ptr[x + 2] * gm) >> 8;
1947 b = (ptr[x + 3] * bm) >> 8;
1948
1949 r |= (!(r >> 8) - 1);
1950 g |= (!(g >> 8) - 1);
1951 b |= (!(b >> 8) - 1);
1952
1953 ptr[x + 1] = r;
1954 ptr[x + 2] = g;
1955 ptr[x + 3] = b;
1956 } else {
1957 r = (ptr[x + 2] * rm) >> 8;
1958 g = (ptr[x + 1] * gm) >> 8;
1959 b = (ptr[x + 0] * bm) >> 8;
1960
1961 r |= (!(r >> 8) - 1);
1962 g |= (!(g >> 8) - 1);
1963 b |= (!(b >> 8) - 1);
1964
1965 ptr[x + 2] = r;
1966 ptr[x + 1] = g;
1967 ptr[x + 0] = b;
1968 }
1969 }
1970 ptr += bpl;
1971 }
1972 }
1973} 2013}
1974
1975#endif 2014#endif
1976 2015
1977/* 2016/*
1978 * Check our parents are still who we think they are. 2017 * Check our parents are still who we think they are.
1979 * Do transparency updates if required 2018 * Do transparency updates if required
… …
2002 if (rootdepth != wattr.depth) 2041 if (rootdepth != wattr.depth)
2003 { 2042 {
2004 if (am_transparent) 2043 if (am_transparent)
2005 { 2044 {
2006 pchanged = 1; 2045 pchanged = 1;
2007 XSetWindowBackground (display->display, TermWin.vt, PixColors[Color_bg]); 2046 XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]);
2008 am_transparent = am_pixmap_trans = 0; 2047 am_transparent = am_pixmap_trans = 0;
2009 } 2048 }
2010 2049
2011 return pchanged; /* Don't try any more */ 2050 return pchanged; /* Don't try any more */
2012 } 2051 }
… …
2028 i = (xa[XA_XSETROOTID] 2067 i = (xa[XA_XSETROOTID]
2029 && XGetWindowProperty (display->display, display->root, xa[XA_XSETROOTID], 2068 && XGetWindowProperty (display->display, display->root, xa[XA_XSETROOTID],
2030 0L, 1L, False, XA_PIXMAP, &atype, &aformat, 2069 0L, 1L, False, XA_PIXMAP, &atype, &aformat,
2031 &nitems, &bytes_after, &prop) == Success); 2070 &nitems, &bytes_after, &prop) == Success);
2032 2071
2033 if (!i || prop == NULL) 2072 if (!i || prop == NULL
2073#if TINTING
2074 || !rs[Rs_color + Color_tint]
2075#endif
2076 )
2034 have_pixmap = 0; 2077 have_pixmap = 0;
2035 else 2078 else
2036 { 2079 {
2037 have_pixmap = 1; 2080 have_pixmap = 1;
2038 rootpixmap = *(Pixmap *)prop; 2081 rootpixmap = *(Pixmap *)prop;
… …
2100 XFreePixmap (display->display, TermWin.pixmap); 2143 XFreePixmap (display->display, TermWin.pixmap);
2101 2144
2102#if TINTING 2145#if TINTING
2103 if (ISSET_PIXCOLOR (Color_tint)) 2146 if (ISSET_PIXCOLOR (Color_tint))
2104 { 2147 {
2105 unsigned short shade, rm, gm, bm; 2148 unsigned short rm, gm, bm;
2149 int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;
2106 2150
2107 PixColors[Color_tint].get (display, rm, gm, bm); 2151 PixColorsFocused[Color_tint].get (display, rm, gm, bm);
2108 2152
2109 rm >>= 8; gm >>= 8; bm >>= 8; // not 100% correct, but... 2153 ShadeXImage (display, image, shade, rm, gm, bm);
2110
2111 /* Determine bitshift and bitmask values */
2112 switch (image->bits_per_pixel)
2113 {
2114 case 15: shade_ximage_15 (image->data, image->bytes_per_line, image->width, image->height, rm, gm, bm); break;
2115 case 16: shade_ximage_16 (image->data, image->bytes_per_line, image->width, image->height, rm, gm, bm); break;
2116 case 24: shade_ximage_24 (image->data, image->bytes_per_line, image->width, image->height, rm, gm, bm); break;
2117 case 32: shade_ximage_32 (image->data, image->bytes_per_line, image->width, image->height, rm, gm, bm); break;
2118 }
2119 } 2154 }
2120#endif 2155#endif
2121 2156
2122 TermWin.pixmap = XCreatePixmap (display->display, TermWin.vt, 2157 TermWin.pixmap = XCreatePixmap (display->display, TermWin.vt,
2123 szHint.width, szHint.height, image->depth); 2158 szHint.width, szHint.height, image->depth);
2124 gc = XCreateGC (display->display, TermWin.vt, 0UL, &gcvalue); 2159 gc = XCreateGC (display->display, TermWin.vt, 0UL, &gcvalue);
2125 XPutImage (display->display, TermWin.pixmap, gc, image, 0, 0, 2160 XPutImage (display->display, TermWin.pixmap, gc, image, 0, 0,
2126 nx, ny, image->width, image->height); 2161 nx, ny, image->width, image->height);
2127 XFreeGC (display->display, gc); 2162 XFreeGC (display->display, gc);
2128 XDestroyImage (image); 2163 XDestroyImage (image);
2129 XSetWindowBackgroundPixmap (display->display, TermWin.vt, 2164 XSetWindowBackgroundPixmap (display->display, TermWin.parent[0], TermWin.pixmap);
2130 TermWin.pixmap); 2165 XClearWindow (display->display, TermWin.parent[0]);
2131 2166
2132 if (!am_transparent || !am_pixmap_trans) 2167 if (!am_transparent || !am_pixmap_trans)
2133 pchanged = 1; 2168 pchanged = 1;
2134 2169
2135 am_transparent = am_pixmap_trans = 1; 2170 am_transparent = am_pixmap_trans = 1;
… …
2180 } 2215 }
2181 2216
2182 if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0]))) 2217 if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0])))
2183 { 2218 {
2184 D_X ((stderr, "InheritPixmap Turning off")); 2219 D_X ((stderr, "InheritPixmap Turning off"));
2185 XSetWindowBackground (display->display, TermWin.parent[0], PixColors[Color_fg]); 2220 XSetWindowBackground (display->display, TermWin.parent[0], PixColorsFocused[Color_fg]);
2186 XSetWindowBackground (display->display, TermWin.vt, PixColors[Color_bg]); 2221 XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]);
2187 am_transparent = 0; 2222 am_transparent = 0;
2188 /* XXX: also turn off Opt_transparent? */ 2223 /* XXX: also turn off Opt_transparent? */
2189 } 2224 }
2190 else 2225 else
2191 { 2226 {
… …
2194 * needed for fvwm2.2.2 (and before?) */ 2229 * needed for fvwm2.2.2 (and before?) */
2195 sleep (1); 2230 sleep (1);
2196#endif 2231#endif
2197 D_X ((stderr, "InheritPixmap Turning on (%d parents)", i - 1)); 2232 D_X ((stderr, "InheritPixmap Turning on (%d parents)", i - 1));
2198 for (n = 0; n < (unsigned int)i; n++) 2233 for (n = 0; n < (unsigned int)i; n++)
2234 {
2199 XSetWindowBackgroundPixmap (display->display, TermWin.parent[n], ParentRelative); 2235 XSetWindowBackgroundPixmap (display->display, TermWin.parent[n], ParentRelative);
2236 XClearWindow (display->display, TermWin.parent[n]);
2237 }
2200 2238
2201 XSetWindowBackgroundPixmap (display->display, TermWin.vt, ParentRelative); 2239 XSetWindowBackgroundPixmap (display->display, TermWin.vt, ParentRelative);
2202 am_transparent = 1; 2240 am_transparent = 1;
2203 } 2241 }
2204 2242
2205 for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++) 2243 for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
2206 TermWin.parent[i] = None; 2244 TermWin.parent[i] = None;
2245 }
2246
2247 // this is experimental
2248 if (scrollBar.win)
2249 {
2250 XSetWindowBackgroundPixmap (display->display, scrollBar.win, ParentRelative);
2251 XClearWindow (display->display, scrollBar.win);
2252 scrollBar.setIdle ();
2253 scrollbar_show (0);
2207 } 2254 }
2208 2255
2209 return pchanged; 2256 return pchanged;
2210} 2257}
2211#endif 2258#endif
… …
2254 { 2301 {
2255 nlines++; 2302 nlines++;
2256 refresh_count++; 2303 refresh_count++;
2257 2304
2258 if (! (Options & Opt_jumpScroll) 2305 if (! (Options & Opt_jumpScroll)
2259 || (refresh_count >= (refresh_limit * (TermWin.nrow - 1)))) 2306 || (refresh_count >= refresh_limit * (TermWin.nrow - 1)))
2260 { 2307 {
2261 refreshnow = true; 2308 refreshnow = true;
2262 flag = true;
2263 ch = NOCHAR; 2309 ch = NOCHAR;
2264 break; 2310 break;
2265 } 2311 }
2266 2312
2267 // scr_add_lines only works for nlines < TermWin.nrow - 1. 2313 // scr_add_lines only works for nlines < TermWin.nrow - 1.
… …
2285 /* 2331 /*
2286 * If there have been a lot of new lines, then update the screen 2332 * If there have been a lot of new lines, then update the screen
2287 * What the heck I'll cheat and only refresh less than every page-full. 2333 * What the heck I'll cheat and only refresh less than every page-full.
2288 * the number of pages between refreshes is refresh_limit, which 2334 * the number of pages between refreshes is refresh_limit, which
2289 * is incremented here because we must be doing flat-out scrolling. 2335 * is incremented here because we must be doing flat-out scrolling.
2290 *
2291 * refreshing should be correct for small scrolls, because of the
2292 * time-out
2293 */ 2336 */
2294 if (refreshnow) 2337 if (refreshnow)
2295 { 2338 {
2296 if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD) 2339 if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)
2297 refresh_limit++; 2340 refresh_limit++;
2298 else 2341 else
2342 {
2343 flag = true;
2299 scr_refresh (refresh_type); 2344 scr_refresh (refresh_type);
2345 }
2300 } 2346 }
2301 2347
2302 } 2348 }
2303 else 2349 else
2304 { 2350 {
… …
3252 if (str[0] == '?' && !str[1]) 3298 if (str[0] == '?' && !str[1])
3253 { 3299 {
3254 if (Options & Opt_insecure) 3300 if (Options & Opt_insecure)
3255 { 3301 {
3256 unsigned short r, g, b; 3302 unsigned short r, g, b;
3257 PixColors[color].get (display, r, g, b); 3303 PixColorsFocused[color].get (display, r, g, b);
3258 tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, r, g, b, resp); 3304 tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, r, g, b, resp);
3259 } 3305 }
3260 } 3306 }
3261 else 3307 else
3262 set_window_color (color, str); 3308 set_window_color (color, str);
… …
3367 if (name[0] == '?' && !name[1]) 3413 if (name[0] == '?' && !name[1])
3368 { 3414 {
3369 if (Options & Opt_insecure) 3415 if (Options & Opt_insecure)
3370 { 3416 {
3371 unsigned short r, g, b; 3417 unsigned short r, g, b;
3372 PixColors[color + minCOLOR].get (display, r, g, b); 3418 PixColorsFocused[color + minCOLOR].get (display, r, g, b);
3373 tt_printf ("\033]%d;%d;rgb:%04x/%04x/%04x%c", XTerm_Color, color, r, g, b, resp); 3419 tt_printf ("\033]%d;%d;rgb:%04x/%04x/%04x%c", XTerm_Color, color, r, g, b, resp);
3374 } 3420 }
3375 } 3421 }
3376 else 3422 else
3377 set_window_color (color + minCOLOR, name); 3423 set_window_color (color + minCOLOR, name);
… …
3750 rendset = 0, rendstyle = ~RS_None; 3796 rendset = 0, rendstyle = ~RS_None;
3751 break; 3797 break;
3752 case 1: 3798 case 1:
3753 rendset = 1, rendstyle = RS_Bold; 3799 rendset = 1, rendstyle = RS_Bold;
3754 break; 3800 break;
3801 //case 2: // faint or second colour
3755 case 4: 3802 case 4:
3756 rendset = 1, rendstyle = RS_Uline; 3803 rendset = 1, rendstyle = RS_Uline;
3757 break; 3804 break;
3758 case 5: 3805 case 5: // slowly blinking
3806 case 6: // rapidly blinking
3759 rendset = 1, rendstyle = RS_Blink; 3807 rendset = 1, rendstyle = RS_Blink;
3760 break; 3808 break;
3761 //case 6: // scoansi light background 3809 //case 6: // scoansi light background
3762 case 7: 3810 case 7:
3763 rendset = 1, rendstyle = RS_RVid; 3811 rendset = 1, rendstyle = RS_RVid;
3764 break; 3812 break;
3765 case 8: 3813 case 8:
3766 // invisible. NYI 3814 // invisible. NYI
3767 break; 3815 break;
3816 //case 9: // crossed out
3768 //case 10: // scoansi acs off 3817 //case 10: // scoansi acs off, primary font
3769 //case 11: // scoansi acs on 3818 //case 11: // scoansi acs on, first alt font
3770 //case 12: // scoansi acs on, |0x80 3819 //case 12: // scoansi acs on, |0x80, second alt font
3771 case 21: // disable bold, blink and invis (some terminals use this) 3820 //...
3821 //case 19: // ninth alt font
3822 //case 20: // gothic
3823 case 21: // disable bold, faint
3772 rendset = 0, rendstyle = RS_Bold | RS_Blink; 3824 rendset = 0, rendstyle = RS_Bold;
3773 break; 3825 break;
3774 case 22: 3826 case 22:
3775 rendset = 0, rendstyle = RS_Bold; 3827 rendset = 0, rendstyle = RS_Bold;
3776 break; 3828 break;
3829 //case 23: disable italic
3777 case 24: 3830 case 24:
3778 rendset = 0, rendstyle = RS_Uline; 3831 rendset = 0, rendstyle = RS_Uline;
3779 break; 3832 break;
3780 case 25: 3833 case 25:
3781 rendset = 0, rendstyle = RS_Blink; 3834 rendset = 0, rendstyle = RS_Blink;
3782 break; 3835 break;
3783 case 27: 3836 case 27:
3784 rendset = 0, rendstyle = RS_RVid; 3837 rendset = 0, rendstyle = RS_RVid;
3785 break; 3838 break;
3786 case 28:
3787 // visible. NYI 3839 //case 28: // visible. NYI
3788 break; 3840 //case 29: // not crossed-out
3789 } 3841 }
3790 3842
3791 if (rendset != -1) 3843 if (rendset != -1)
3792 { 3844 {
3793 scr_rendition (rendset, rendstyle); 3845 scr_rendition (rendset, rendstyle);

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines