diff options
Diffstat (limited to 'xorg-server/hw/xfree86/utils/xorgcfg/xf86config.c')
| -rw-r--r-- | xorg-server/hw/xfree86/utils/xorgcfg/xf86config.c | 982 |
1 files changed, 982 insertions, 0 deletions
diff --git a/xorg-server/hw/xfree86/utils/xorgcfg/xf86config.c b/xorg-server/hw/xfree86/utils/xorgcfg/xf86config.c new file mode 100644 index 000000000..2c667dcde --- /dev/null +++ b/xorg-server/hw/xfree86/utils/xorgcfg/xf86config.c @@ -0,0 +1,982 @@ +/* + * Copyright (c) 2000 by Conectiva S.A. (http://www.conectiva.com) + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * CONECTIVA LINUX BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * Except as contained in this notice, the name of Conectiva Linux shall + * not be used in advertising or otherwise to promote the sale, use or other + * dealings in this Software without prior written authorization from + * Conectiva Linux. + * + * Author: Paulo César Pereira de Andrade <pcpa@conectiva.com.br> + * + */ + +#include "xf86config.h" + +/* + * Implementation + */ +int +xf86removeOption(XF86OptionPtr *options, char *name) +{ + XF86OptionPtr opt = *options, prev = opt; + + while (opt) { + if (strcasecmp(opt->opt_name, name) == 0) { + XtFree(opt->opt_name); + XtFree(opt->opt_val); + XtFree(opt->opt_comment); + if (opt == prev) + *options = (XF86OptionPtr)(opt->list.next); + else + prev->list.next = opt->list.next; + XtFree((XtPointer)opt); + + return (True); + } + + prev = opt; + opt = (XF86OptionPtr)(opt->list.next); + } + + return (False); +} + +int +xf86removeInput(XF86ConfigPtr config, XF86ConfInputPtr input) +{ + XF86ConfInputPtr prev, inp = config->conf_input_lst; + XF86ConfLayoutPtr lay = config->conf_layout_lst; + + /* remove from main structure */ + prev = inp; + while (inp != NULL) { + if (inp == input) { + if (inp == prev) + config->conf_input_lst = (XF86ConfInputPtr)(inp->list.next); + else + prev->list.next = inp->list.next; + break; + } + prev = inp; + inp = (XF86ConfInputPtr)(inp->list.next); + } + + if (inp == NULL) + return (False); + + /* remove references */ + while (lay != NULL) { + xf86removeInputRef(lay, inp); + lay = (XF86ConfLayoutPtr)(lay->list.next); + } + + XtFree(inp->inp_identifier); + XtFree(inp->inp_driver); + XtFree(inp->inp_comment); + xf86optionListFree(inp->inp_option_lst); + XtFree((XtPointer)inp); + + return (True); +} + +int +xf86removeInputRef(XF86ConfLayoutPtr layout, XF86ConfInputPtr input) +{ + XF86ConfInputrefPtr prev, iref = layout->lay_input_lst; + + prev = iref; + while (iref != NULL) { + if (iref->iref_inputdev == input) { + XtFree(iref->iref_inputdev_str); + xf86optionListFree(iref->iref_option_lst); + if (prev == iref) + layout->lay_input_lst = + (XF86ConfInputrefPtr)(iref->list.next); + else + prev->list.next = iref->list.next; + XtFree((XtPointer)iref); + + return (True); + } + prev = iref; + iref = (XF86ConfInputrefPtr)(iref->list.next); + } + + return (False); +} + +int +xf86removeDevice(XF86ConfigPtr config, XF86ConfDevicePtr device) +{ + XF86ConfDevicePtr prev, dev = config->conf_device_lst; + XF86ConfScreenPtr psc, scr = config->conf_screen_lst; + + /* remove from main structure */ + prev = dev; + while (dev != NULL) { + if (dev == device) { + if (dev == prev) + config->conf_device_lst = (XF86ConfDevicePtr)(dev->list.next); + else + prev->list.next = dev->list.next; + break; + } + prev = dev; + dev = (XF86ConfDevicePtr)(dev->list.next); + } + + if (dev == NULL) + return (False); + + /* remove references */ + psc = scr; + while (scr != NULL) { + if (scr->scrn_device == device) { + xf86removeScreen(config, scr); + if (scr == psc) + scr = psc = config->conf_screen_lst; + else + scr = psc; + continue; + } + psc = scr; + scr = (XF86ConfScreenPtr)(scr->list.next); + } + + XtFree(dev->dev_identifier); + XtFree(dev->dev_vendor); + XtFree(dev->dev_board); + XtFree(dev->dev_chipset); + XtFree(dev->dev_busid); + XtFree(dev->dev_card); + XtFree(dev->dev_driver); + XtFree(dev->dev_ramdac); + XtFree(dev->dev_clockchip); + XtFree(dev->dev_comment); + xf86optionListFree(dev->dev_option_lst); + XtFree((XtPointer)dev); + + return (True); +} + +int +xf86removeMonitor(XF86ConfigPtr config, XF86ConfMonitorPtr monitor) +{ + XF86ConfMonitorPtr prev, mon = config->conf_monitor_lst; + XF86ConfScreenPtr psc, scr = config->conf_screen_lst; + + /* remove from main structure */ + prev = mon; + while (mon != NULL) { + if (mon == monitor) { + if (mon == prev) + config->conf_monitor_lst = (XF86ConfMonitorPtr)(mon->list.next); + else + prev->list.next = mon->list.next; + break; + } + prev = mon; + mon = (XF86ConfMonitorPtr)(mon->list.next); + } + + if (mon == NULL) + return (False); + + /* remove references */ + psc = scr; + while (scr != NULL) { + if (scr->scrn_monitor == monitor) { + xf86removeScreen(config, scr); + if (scr == psc) + scr = psc = config->conf_screen_lst; + else + scr = psc; + continue; + } + psc = scr; + scr = (XF86ConfScreenPtr)(scr->list.next); + } + + XtFree(mon->mon_identifier); + XtFree(mon->mon_vendor); + XtFree(mon->mon_modelname); + XtFree(mon->mon_comment); + xf86optionListFree(mon->mon_option_lst); + XtFree((XtPointer)mon); + + return (True); +} + +int +xf86removeScreen(XF86ConfigPtr config, XF86ConfScreenPtr screen) +{ + XF86ConfScreenPtr prev, scrn; + XF86ConfLayoutPtr lay; + + if (config == NULL || screen == NULL) + return (False); + + lay = config->conf_layout_lst; + prev = scrn = config->conf_screen_lst; + + while (scrn != NULL) { + if (scrn == screen) { + if (scrn == prev) + config->conf_screen_lst = (XF86ConfScreenPtr)(scrn->list.next); + else + prev->list.next = scrn->list.next; + break; + } + prev = scrn; + scrn = (XF86ConfScreenPtr)(scrn->list.next); + } + + if (scrn == NULL) + return (False); + + while (lay != NULL) { + XF86ConfAdjacencyPtr pad, ad = NULL, adj = lay->lay_adjacency_lst; + + pad = adj; + while (adj) { + if (adj->adj_screen == screen) + ad = adj; + else { + if (adj->adj_top != NULL && adj->adj_top == screen) { + XtFree(adj->adj_top_str); + adj->adj_top_str = NULL; + adj->adj_top = NULL; + } + else if (adj->adj_bottom != NULL && adj->adj_bottom == screen) { + XtFree(adj->adj_bottom_str); + adj->adj_bottom_str = NULL; + adj->adj_bottom = NULL; + } + else if (adj->adj_left != NULL && adj->adj_left == screen) { + XtFree(adj->adj_left_str); + adj->adj_left_str = NULL; + adj->adj_left = NULL; + } + else if (adj->adj_right != NULL && adj->adj_right == screen) { + XtFree(adj->adj_right_str); + adj->adj_right_str = NULL; + adj->adj_right = NULL; + } + else if (adj->adj_refscreen != NULL && + strcasecmp(scrn->scrn_identifier, + adj->adj_refscreen) == 0) { + XtFree(adj->adj_refscreen); + adj->adj_refscreen = NULL; + adj->adj_where = CONF_ADJ_ABSOLUTE; + adj->adj_x = adj->adj_y = 0; + } + } + if (ad == NULL) + pad = adj; + adj = (XF86ConfAdjacencyPtr)(adj->list.next); + } + + if (ad != NULL) { + if (ad == lay->lay_adjacency_lst) + lay->lay_adjacency_lst = (XF86ConfAdjacencyPtr)(ad->list.next); + else + pad->list.next = (XF86ConfAdjacencyPtr)(ad->list.next); + XtFree(ad->adj_screen_str); + XtFree(ad->adj_top_str); + XtFree(ad->adj_bottom_str); + XtFree(ad->adj_left_str); + XtFree(ad->adj_right_str); + XtFree(ad->adj_refscreen); + XtFree((XtPointer)ad); + } + + lay = (XF86ConfLayoutPtr)(lay->list.next); + } + + xf86freeAdaptorLinkList(screen->scrn_adaptor_lst); + xf86freeDisplayList(screen->scrn_display_lst); + + XtFree(screen->scrn_identifier); + XtFree(screen->scrn_monitor_str); + XtFree(screen->scrn_device_str); + xf86optionListFree(screen->scrn_option_lst); + XtFree((XtPointer)screen); + + return (True); +} + +int +xf86removeAdjacency(XF86ConfLayoutPtr layout, XF86ConfAdjacencyPtr adjacency) +{ + XF86ConfAdjacencyPtr prev, adj = layout->lay_adjacency_lst; + + if (layout == NULL || adjacency == NULL) + return (False); + + prev = adj; + while (adj != NULL) { + if (adj == adjacency) + break; + prev = adj; + adj = (XF86ConfAdjacencyPtr)(adj->list.next); + } + if (adj == NULL) + return (False); + + XtFree(adj->adj_screen_str); + XtFree(adj->adj_top_str); + XtFree(adj->adj_bottom_str); + XtFree(adj->adj_left_str); + XtFree(adj->adj_right_str); + XtFree(adj->adj_refscreen); + if (prev == adj) + layout->lay_adjacency_lst = (XF86ConfAdjacencyPtr)(adj->list.next); + else + prev->list.next = adj->list.next; + XtFree((XtPointer)adj); + + return (True); +} + +int +xf86removeInactive(XF86ConfLayoutPtr layout, XF86ConfInactivePtr inactive) +{ + XF86ConfInactivePtr prev, inac = layout->lay_inactive_lst; + + if (layout == NULL || inactive == NULL) + return (False); + + prev = inac; + while (inac != NULL) { + if (inac == inactive) + break; + prev = inac; + inac = (XF86ConfInactivePtr)(inac->list.next); + } + if (inac == NULL) + return (False); + + XtFree(inac->inactive_device_str); + if (prev == inac) + layout->lay_inactive_lst = (XF86ConfInactivePtr)(inac->list.next); + else + prev->list.next = inac->list.next; + XtFree((XtPointer)inac); + + return (True); +} + +int +xf86removeLayout(XF86ConfigPtr config, XF86ConfLayoutPtr layout) +{ + XF86ConfLayoutPtr prev, lay = config->conf_layout_lst; + XF86ConfAdjacencyPtr adj, nadj; + XF86ConfInactivePtr inac, ninac; + XF86ConfInputrefPtr iref, niref; + + if (config == NULL || layout == NULL) + return (False); + + prev = lay; + while (lay != NULL) { + if (lay == layout) + break; + prev = lay; + lay = (XF86ConfLayoutPtr)(lay->list.next); + } + + if (lay == NULL) + return (False); + + adj = lay->lay_adjacency_lst; + while (adj != NULL) { + nadj = (XF86ConfAdjacencyPtr)(adj->list.next); + xf86removeAdjacency(lay, adj); + adj = nadj; + } + + inac = lay->lay_inactive_lst; + while (inac != NULL) { + ninac = (XF86ConfInactivePtr)(inac->list.next); + xf86removeInactive(lay, inac); + inac = ninac; + } + + iref = lay->lay_input_lst; + while (iref != NULL) { + niref = (XF86ConfInputrefPtr)(iref->list.next); + xf86removeInputRef(lay, iref->iref_inputdev); + iref = niref; + } + + xf86optionListFree(lay->lay_option_lst); + + if (prev == lay) + config->conf_layout_lst = (XF86ConfLayoutPtr)(lay->list.next); + else + prev->list.next = lay->list.next; + XtFree(lay->lay_identifier); + XtFree((XtPointer)lay); + + return (True); +} + +int +xf86removeModule(XF86ConfigPtr config, XF86LoadPtr load) +{ + XF86LoadPtr prev, mod; + + if (config == NULL || config->conf_modules == NULL || + config->conf_modules->mod_load_lst == NULL) + return (False); + + for (mod = prev = config->conf_modules->mod_load_lst; + mod != NULL; prev = mod, mod = (XF86LoadPtr)(mod->list.next)) + if (load == mod) { + if (mod == prev) + config->conf_modules->mod_load_lst = + (XF86LoadPtr)(mod->list.next); + else + prev->list.next = mod->list.next; + XtFree(mod->load_name); + xf86optionListFree(mod->load_opt); + + return (True); + } + + return (False); +} + +int +xf86removeModes(XF86ConfigPtr config, XF86ConfModesPtr modes) +{ + XF86ConfModesPtr mod; + XF86ConfModeLinePtr ml, next; + XF86ConfMonitorPtr mon; + + if (config == NULL || modes == NULL) + return (False); + + /* check if modes is in config */ + if ((mod = config->conf_modes_lst) == modes) + config->conf_modes_lst = (XF86ConfModesPtr)(mod->list.next); + else + for (; mod != NULL; mod = (XF86ConfModesPtr)(mod->list.next)) + if ((XF86ConfModesPtr)(mod->list.next) == modes) { + mod->list.next = modes->list.next; + break; + } + + if (mod == NULL) + return (False); + + /* remove references in monitor sections */ + mon = config->conf_monitor_lst; + while (mon) { + XF86ConfModesLinkPtr m, p; + + m = p = mon->mon_modes_sect_lst; + while (m) { + if (m->ml_modes == modes) { + XtFree(m->ml_modes_str); + if (m == mon->mon_modes_sect_lst) + p = mon->mon_modes_sect_lst = + (XF86ConfModesLinkPtr)(m->list.next); + else { + p->list.next = m->list.next; + p = p->list.next; + } + XtFree((XtPointer)m); + m = p; + continue; + } + p = m; + m = (XF86ConfModesLinkPtr)(m->list.next); + } + mon = (XF86ConfMonitorPtr)(mon->list.next); + } + + /* free modelines */ + ml = modes->mon_modeline_lst; + while (ml) { + next = (XF86ConfModeLinePtr)(ml->list.next); + XtFree(ml->ml_identifier); + XtFree((XtPointer)ml); + ml = next; + } + + /* free mode */ + XtFree(modes->modes_identifier); + XtFree((XtPointer)modes); + + return (True); +} + +int +xf86removeModesModeLine(XF86ConfModesPtr modes, XF86ConfModeLinePtr modeline) +{ + XF86ConfModeLinePtr ml, prev; + + if (modes == NULL || modeline == NULL || modes->mon_modeline_lst == NULL) + return (False); + + for (ml = prev = modes->mon_modeline_lst; ml; + prev = ml, ml = (XF86ConfModeLinePtr)(ml->list.next)) + if (ml == modeline) { + if (prev == ml) + modes->mon_modeline_lst = (XF86ConfModeLinePtr)(ml->list.next); + else + prev->list.next = ml->list.next; + XtFree(modeline->ml_identifier); + XtFree((XtPointer)modeline); + return (True); + } + + return (False); +} + +int +xf86removeMonitorModeLine(XF86ConfMonitorPtr monitor, XF86ConfModeLinePtr modeline) +{ + XF86ConfModeLinePtr ml, prev; + + if (monitor == NULL || modeline == NULL || monitor->mon_modeline_lst == NULL) + return (False); + + for (ml = prev = monitor->mon_modeline_lst; ml; + prev = ml, ml = (XF86ConfModeLinePtr)(ml->list.next)) + if (ml == modeline) { + if (prev == ml) + monitor->mon_modeline_lst = (XF86ConfModeLinePtr)(ml->list.next); + else + prev->list.next = ml->list.next; + XtFree(modeline->ml_identifier); + XtFree((XtPointer)modeline); + return (True); + } + + return (False); +} + +int +xf86removeMonitorModesLink(XF86ConfMonitorPtr monitor, XF86ConfModesLinkPtr link) +{ + XF86ConfModesLinkPtr lnk, prev; + + if (monitor == NULL || link == NULL || monitor->mon_modes_sect_lst == NULL) + return (False); + + for (lnk = prev = monitor->mon_modes_sect_lst; lnk != NULL; + prev = lnk, lnk = (XF86ConfModesLinkPtr)(lnk->list.next)) + if (lnk == link) { + if (prev == lnk) + monitor->mon_modes_sect_lst = (XF86ConfModesLinkPtr)(lnk->list.next); + else + prev->list.next = lnk->list.next; + XtFree(link->ml_modes_str); + XtFree((XtPointer)link); + + return (True); + } + + return (False); +} + +int +xf86removeScreenAdaptorLink(XF86ConfScreenPtr scrn, XF86ConfAdaptorLinkPtr link) +{ + XF86ConfAdaptorLinkPtr lnk, prev; + + if (scrn == NULL || link == NULL || scrn->scrn_adaptor_lst == NULL) + return (False); + + for (lnk = prev = scrn->scrn_adaptor_lst; lnk != NULL; + prev = lnk, lnk = (XF86ConfAdaptorLinkPtr)(lnk->list.next)) + if (lnk == link) { + if (prev == lnk) + scrn->scrn_adaptor_lst = + (XF86ConfAdaptorLinkPtr)(lnk->list.next); + else + prev->list.next = lnk->list.next; + XtFree(link->al_adaptor_str); + XtFree((XtPointer)link); + + return (True); + } + + return (False); +} + +int +xf86removeScreenDisplay(XF86ConfScreenPtr scrn, XF86ConfDisplayPtr display) +{ + XF86ConfDisplayPtr dsp, prev; + + if (scrn == NULL || display == NULL || scrn->scrn_display_lst == NULL) + return (False); + + for (dsp = prev = scrn->scrn_display_lst; dsp != NULL; + prev = dsp, dsp = (XF86ConfDisplayPtr)(dsp->list.next)) + if (dsp == display) { + if (prev == dsp) + scrn->scrn_display_lst = + (XF86ConfDisplayPtr)(dsp->list.next); + else + prev->list.next = dsp->list.next; + xf86optionListFree(display->disp_option_lst); + XtFree((XtPointer)display->disp_visual); + xf86freeModeList(display->disp_mode_lst); + XtFree((XtPointer)display); + + return (True); + } + + return (False); +} + +int +xf86removeVideoAdaptor(XF86ConfigPtr config, XF86ConfVideoAdaptorPtr video) +{ + XF86ConfVideoAdaptorPtr vid; + XF86ConfScreenPtr scrn; + XF86ConfVideoPortPtr vp, next; + + if (config == NULL || video == NULL) + return (False); + + /* check if video is in config and update videoadaptor list */ + if ((vid = config->conf_videoadaptor_lst) == video) + config->conf_videoadaptor_lst = (XF86ConfVideoAdaptorPtr)(vid->list.next); + else + for (; vid != NULL; vid = (XF86ConfVideoAdaptorPtr)(vid->list.next)) + if ((XF86ConfVideoAdaptorPtr)(vid->list.next) == video) { + vid->list.next = video->list.next; + break; + } + + if (vid == NULL) + return (False); + + /* remove references in screen sections */ + scrn = config->conf_screen_lst; + while (scrn) { + XF86ConfAdaptorLinkPtr v, p; + + v = p = scrn->scrn_adaptor_lst; + while (v) { + if (v->al_adaptor == video) { + XtFree(v->al_adaptor_str); + if (v == scrn->scrn_adaptor_lst) + p = scrn->scrn_adaptor_lst = + (XF86ConfAdaptorLinkPtr)(v->list.next); + else { + p->list.next = v->list.next; + p = p->list.next; + } + XtFree((XtPointer)v); + v = p; + continue; + } + p = v; + v = (XF86ConfAdaptorLinkPtr)(v->list.next); + } + scrn = (XF86ConfScreenPtr)(scrn->list.next); + } + + /* free videoports */ + vp = video->va_port_lst; + while (vp) { + next = (XF86ConfVideoPortPtr)(vp->list.next); + XtFree(vp->vp_identifier); + xf86optionListFree(vp->vp_option_lst); + XtFree((XtPointer)vp); + vp = next; + } + + /* free videoadaptor */ + XtFree(video->va_identifier); + XtFree(video->va_vendor); + XtFree(video->va_board); + XtFree(video->va_busid); + XtFree(video->va_driver); + XtFree(video->va_fwdref); + xf86optionListFree(video->va_option_lst); + XtFree((XtPointer)video); + + return (True); +} + +int +xf86removeVideoPort(XF86ConfVideoAdaptorPtr va, XF86ConfVideoPortPtr vp) +{ + XF86ConfVideoPortPtr prev; + + if (va == NULL || vp == NULL) + return (False); + + if ((prev = va->va_port_lst) == vp) + va->va_port_lst = (XF86ConfVideoPortPtr)(va->va_port_lst->list.next); + else { + while (prev && (XF86ConfVideoPortPtr)(prev->list.next) != vp) + prev = (XF86ConfVideoPortPtr)(prev->list.next); + if (prev == NULL) + return (False); + prev->list.next = vp->list.next; + } + + xf86optionListFree(vp->vp_option_lst); + XtFree((XtPointer)vp); + + return (True); +} + +int +xf86removeDisplayMode(XF86ConfDisplayPtr display, XF86ModePtr mode) +{ + XF86ModePtr prev; + + if (display == NULL || mode == NULL) + return (False); + + if ((prev = display->disp_mode_lst) == mode) + display->disp_mode_lst = (XF86ModePtr)(display->disp_mode_lst->list.next); + else { + while (prev && (XF86ModePtr)(prev->list.next) != mode) + prev = (XF86ModePtr)(prev->list.next); + if (prev == NULL) + return (False); + prev->list.next = mode->list.next; + } + + XtFree((XtPointer)mode); + + return (True); +} + +int +xf86removeVendor(XF86ConfigPtr config, XF86ConfVendorPtr vendor) +{ + XF86ConfVendorPtr prev; + + if (config == NULL || vendor == NULL) + return (False); + + if ((prev = config->conf_vendor_lst) == vendor) + config->conf_vendor_lst = (XF86ConfVendorPtr)(config->conf_vendor_lst->list.next); + else { + while (prev && (XF86ConfVendorPtr)(prev->list.next) != vendor) + prev = (XF86ConfVendorPtr)(prev->list.next); + if (prev == NULL) + return (False); + prev->list.next = vendor->list.next; + } + + xf86optionListFree(vendor->vnd_option_lst); + xf86freeVendorSubList(vendor->vnd_sub_lst); + XtFree(vendor->vnd_identifier); + XtFree((XtPointer)vendor); + + return (True); +} + +int +xf86removeVendorSub(XF86ConfVendorPtr vendor, XF86ConfVendSubPtr sub) +{ + XF86ConfVendSubPtr prev; + + if (vendor == NULL || sub == NULL) + return (False); + + if ((prev = vendor->vnd_sub_lst) == sub) + vendor->vnd_sub_lst = (XF86ConfVendSubPtr)(vendor->vnd_sub_lst->list.next); + else { + while (prev && (XF86ConfVendSubPtr)(prev->list.next) != sub) + prev = (XF86ConfVendSubPtr)(prev->list.next); + if (prev == NULL) + return (False); + prev->list.next = sub->list.next; + } + + xf86optionListFree(sub->vs_option_lst); + XtFree(sub->vs_name); + XtFree(sub->vs_identifier); + XtFree((XtPointer)sub); + + return (True); +} + +int +xf86removeBuffers(XF86ConfDRIPtr dri, XF86ConfBuffersPtr buf) +{ + XF86ConfBuffersPtr prev; + + if (dri == NULL || buf == NULL) + return (False); + + if ((prev = dri->dri_buffers_lst) == buf) + dri->dri_buffers_lst = (XF86ConfBuffersPtr)(dri->dri_buffers_lst->list.next); + else { + while (prev && (XF86ConfBuffersPtr)(prev->list.next) != buf) + prev = (XF86ConfBuffersPtr)(prev->list.next); + if (prev == NULL) + return (False); + prev->list.next = buf->list.next; + } + + XtFree(buf->buf_flags); + XtFree((XtPointer)buf); + + return (True); +} + +int +xf86renameInput(XF86ConfigPtr config, XF86ConfInputPtr input, char *name) +{ + XF86ConfLayoutPtr lay = config->conf_layout_lst; + + if (config == NULL || input == NULL || name == NULL || *name == '\0') + return (False); + + while (lay != NULL) { + XF86ConfInputrefPtr iref = lay->lay_input_lst; + + while (iref != NULL) { + if (strcasecmp(input->inp_identifier, iref->iref_inputdev_str) == 0) { + XtFree(iref->iref_inputdev_str); + iref->iref_inputdev_str = XtNewString(name); + } + iref = (XF86ConfInputrefPtr)(iref->list.next); + } + lay = (XF86ConfLayoutPtr)(lay->list.next); + } + + XtFree(input->inp_identifier); + input->inp_identifier = XtNewString(name); + + return (True); +} + +int +xf86renameDevice(XF86ConfigPtr config, XF86ConfDevicePtr dev, char *name) +{ + XF86ConfScreenPtr scr = config->conf_screen_lst; + + if (config == NULL || dev == NULL || name == NULL || *name == '\0') + return (False); + + while (scr != NULL) { + if (scr->scrn_device == dev) { + XtFree(scr->scrn_device_str); + scr->scrn_device_str = XtNewString(name); + } + + scr = (XF86ConfScreenPtr)(scr->list.next); + } + + XtFree(dev->dev_identifier); + dev->dev_identifier = XtNewString(name); + + return (True); +} + +int +xf86renameMonitor(XF86ConfigPtr config, XF86ConfMonitorPtr mon, char *name) +{ + XF86ConfScreenPtr scr = config->conf_screen_lst; + + if (config == NULL || mon == NULL || name == NULL || *name == '\0') + return (False); + + while (scr != NULL) { + if (scr->scrn_monitor == mon) { + XtFree(scr->scrn_monitor_str); + scr->scrn_monitor_str = XtNewString(name); + } + + scr = (XF86ConfScreenPtr)(scr->list.next); + } + + XtFree(mon->mon_identifier); + mon->mon_identifier = XtNewString(name); + + return (True); +} + +int +xf86renameLayout(XF86ConfigPtr config, XF86ConfLayoutPtr layout, char *name) +{ + if (config == NULL || layout == NULL || name == NULL || *name == '\0') + return (False); + + XtFree(layout->lay_identifier); + layout->lay_identifier = XtNewString(name); + + return (True); +} + +int +xf86renameScreen(XF86ConfigPtr config, XF86ConfScreenPtr scrn, char *name) +{ + XF86ConfLayoutPtr lay = config->conf_layout_lst; + + if (config == NULL || scrn == NULL || name == NULL || *name == '\0') + return (False); + + while (lay != NULL) { + XF86ConfAdjacencyPtr adj = lay->lay_adjacency_lst; + + while (adj != NULL) { + if (adj->adj_screen == scrn) { + XtFree(adj->adj_screen_str); + adj->adj_screen_str = XtNewString(name); + } + else if (adj->adj_top == scrn) { + XtFree(adj->adj_top_str); + adj->adj_top_str = XtNewString(name); + } + else if (adj->adj_bottom == scrn) { + XtFree(adj->adj_bottom_str); + adj->adj_bottom_str = XtNewString(name); + } + else if (adj->adj_left == scrn) { + XtFree(adj->adj_left_str); + adj->adj_left_str = XtNewString(name); + } + else if (adj->adj_right == scrn) { + XtFree(adj->adj_right_str); + adj->adj_right_str = XtNewString(name); + } + else if (adj->adj_refscreen != NULL && + strcasecmp(adj->adj_refscreen, name) == 0) { + XtFree(adj->adj_refscreen); + adj->adj_refscreen = XtNewString(name); + } + + adj = (XF86ConfAdjacencyPtr)(adj->list.next); + } + lay = (XF86ConfLayoutPtr)(lay->list.next); + } + + XtFree(scrn->scrn_identifier); + scrn->scrn_identifier = XtNewString(name); + + return (True); +} |