CN1311346C - A method for providing graphic control and a theme management system - Google Patents

Abstract

A system and method are described that use a theme function of a theme manager to provide graphical components in a theme manner. The theme manager uses theme files having theme properties for all types of graphical components. When an application is started, the provided system determines whether the application supports the theme composition. If the application supports the theme composition, a dynamic connection control library supporting the theme is connected to the application. If the application does not support the theme composition, then the non-theme control library is connected. If the application supports the theme, user controls and shell common controls for the application with the theme are provided by using a theme control library function that interacts with a function of the theme manager. Non-client widgets using themes are provided by intercepting a provide message to a window and sending the message to a theme manager. Non-client widgets that use theme properties are also measured and provided when appropriate in response to certain application program interface calls.

Description

A method for providing graphic control and a theme management system

technical field

The present invention relates to computer systems, and more particularly to theme aware management using fusions when provisioning system components.

Background technique

Computer users in business and home environments have become accustomed to using computers with graphical operating systems. For example, many users operate computers on which Microsoft Corporation's "Windows" operating system is installed. Certain components of these graphical operating systems are known as "controls." For example, one control could be an "OK" button, which is usually a rectangular button with "OK" written in it. By moving the cursor over the button and clicking the mouse, a known action associated with that control will be initiated. There are many other controls including, for example, scroll bars, dialog boxes, and sliders. In addition to controls, a graphics operating system draws or provides other graphical components as needed on a computer display, such as frame, minimize, and close boxes.

There are two common types of controls in Windows: standard controls and user controls. Standard controls are provided by the operating system. The code to create, draw and drag standard controls is contained in a common control library (DLL), which is part of the window. User controls are all other controls. User controls can be created by the manufacturer of the operating system or by a third party. The code for the user control is contained in a corresponding separate library (DLL) or in the application.

Currently, when a graphical user interface component, such as a control, is used by an application, the application requests that an instance of the component be created. Following this, the operating system transmits a class message to the component, instructing the component to provide itself. The application works in routing messages from the main window to the target control, but the control code does the drawing. The application uses an Application Programming Interface (API) to create and interact with the control. The API serves as a software interface used by other programs, similar to how a keypad is used as an interface for a calculator. API is the basic concept of high-level programming. In high-level programming, the program often does not perform tasks by itself. Rather, the program requires some other program to perform the tasks. For example, programs frequently delegate various tasks to the underlying operating system. Continuing with the above example, the application delegates the provision of the control to the control's code.

In a prior art environment, when a class message is received by a control providing itself, the control will draw itself using its own drawing software code. In the context of this prior art, the control knows what is considered to be like, how it is considered to act, and is able to effectuate this display on the computer's user interface. Thus, an application can delegate all aspects of visual rendering to these controls, avoiding the need to include software code that supports visual rendering of the control within its host application.

By utilizing the standard controls defined and provided by the operating system, all controls will have the same appearance, independent of the application. A user of a graphical operating system can only change a limited number of features of a control. In the "Windows" operating system, a user can change the color scheme used to display various controls and widgets on a monitor. Users can also select a small set of fonts to be used by controls and components. Therefore, the color, font, and size of a limited amount of controls and components can be changed. However, the basic appearance of widgets and widgets is determined by supplying software code in widget libraries that contain specific graphical widgets or widgets. In prior art environments, in order to change the appearance of a control or a graphical component, it was necessary to change the provisioning software code. For example, if one wishes to change the appearance of the "OK" button, the supply software code must be changed in the operating system DLL file containing the button control, and the DLL file rebuilt at the binary level. If it were desired to provide buttons as ellipses rather than as traditional rectangles, the software code would have to be changed accordingly. This approach would make it difficult for computer users and software manufacturers (if possible) to easily change the appearance of controls and graphical components.

In order to enhance the user experience of a computer, users desire the ability to change the overall "look and feel" of a graphical display by changing the overall visible appearance or "theme" of the various graphical components. In other words, if the user can not only change the color and font style of the graphic parts appearing on the monitor, it is desirable to be able to change the appearance of these graphic parts as well. For example, it is desirable to be able to change and control the configuration of a control's components, as well as define the shape of a control or its components. You also want to control how all aspects of the control or its parts are drawn. Since the controls and graphics components present in the DLL files of the prior art environment are "hardcoded" with their own provided software code, it is difficult and cumbersome to change the appearance of all these controls and components. Doing so requires recoding each control to achieve the desired appearance. If multiple visible formats are required, each of them will have to be pre-defined and each "hard-coded" into each control. Also, be sure to document these controls if you want to use a different delivery technology. For example, if you are using a bitmap to provide these controls and want to use a vector provider, be sure to change each control.

Certain prior art methods attempt to address the above states. However, these solutions do not allow all controls and graphics components of the entire system to be changed. In contrast, prior art methods only address a limited portion of the family of displayed components. This makes it possible to change the appearance of some controls and graphics components, but not others. This approach prevents appearance from being coordinated as desired.

Prior art methods are further limited by this technique, and they are used to achieve control of the appearance characteristics of the visible elements of the graphical user interface. Prior art skin changers operate by intercepting class-provided signals passed to the control and using the low-level operating system graphics API, substituting the control's provided code for their own. However, only some of the visible elements in the GUI are clippable. Since prior art methods rely only on the interruption of operating system signals, not only are they themselves unable to control the appearance of visible units that do not function according to the protocol, they are also unable to provide standard tools to authors of visible units to modify provided code. to accommodate external controls.

Similarly, prior art methods for providing non-client widgets such as window frames and minimize boxes have disadvantages. The prior art approach required the user to purchase a separate software package in order to support thematic composition of these components. Prior art methods are incomplete because they only allow fixed sub-families of controls to be themeable. Moreover, they implement composition interrupts that rely only on standard window messages, without any USER32 knowledge of controls or theme drawing.

In traditional operating systems, non-client widgets have been provided by the default window program in the window kernel model, which responds to composite window messages and API calls. It would be impractical to fit all theme variables into a single default window procedure. Adding theme features to the default window process would require more complex code, complete recompilation of the code, and painstaking testing to determine if the code improves functionality appropriately and does not break any existing applications.

Also, during provisioning, it is not possible to interrupt all relevant signals transmitted by the operating system to the control. In addition, it is impossible to reproduce complex visual behaviors implemented by controls such as activation sequences, either in traditional operating systems or in separate software package theming methods. Therefore, prior art approaches, including operating system approaches and approaches implemented by separate software packages, are prone to functional incompatibilities, visual deficiencies, and performance problems.

Also, the prior art is limited in the way that software developers can design controls that satisfy generality on a visible surface. Using traditional "owner-paint" and "user-paint" approaches, application developers have been able to provide controls with only a limited set of items. Prior art approaches do not contain this structure, which allows control authors the flexibility to design controls that are "theme aware". Therefore, the author of the control is not allowed the degree of freedom that is required in creating controls that can be easily and clearly visibly changed.

Also, a system that provides theme-aware controls should contain legacy applications as well as new applications that can work with theme-aware controls. Legacy applications have been developed and tested to work with legacy controls that are not theme aware. A new application has been developed and tested to work with the subject-aware controls. A topic-aware architecture must allow both types of applications to work on the same computer system.

For example, if a system that provides themes requires that all applications use themed components, even if they have not been tested with new controls, application controls will not be provided when the application developer expects them. Accordingly, these controls may appear to be inconsistent with the appearance of the application, or be in the wrong place relative to the application, or may cease to function altogether. Application authors should be able to control whether their applications use the new composition theme or continue to use legacy controls.

Another problem is that new applications cannot work on legacy systems that are not subject-aware. New applications will be developed and tested for the new system that provides the subject. When these new applications are loaded onto legacy systems that are not themed aware, not only will the application's controls not be themed, but in many cases the application will fail. Therefore, there is no way for a topic-aware application to work on a non-topic-aware system.

Contents of the invention

According to the present invention, the above-mentioned problems are solved by creating a theme-aware version of the control and applying a software component selection technique called "fusion" to select a theme-aware version for a theme-capable application . The present invention includes a relay function that transfers windowing and size requests from the default windowing function to the theme-aware windowing function.

One aspect of the invention is a system and method for linking one of two sets of control functions into an application memory map after it has been determined whether the application supports theme composition capabilities. The system determines whether the application has a manifest file indicating the theme composition groups that use the control functions. The widget theme composition group can interact with the theme manager's functions to theme graphical components.

The system and method also includes an interception branch that intercepts the offer message to the window. The interception branch selects the provisioning message from the default window provisioning routine and sends the message to the theme manager function that provides the graphical components of the window in themes. API calls are also routed to the theme manager so that in response to the API, the window non-client graphics components can be measured or provided using themes. The systems and methods also include methods for providing user controls and shell common controls by using a set of theme control functions that interact with functions of a theme manager that presents controls in a theme manner.

The invention can be implemented in a computer process, a computing system or in a manufacturer's product such as a computer programming product or a computer readable medium.

According to the present invention, there is provided a theme management system configured to provide graphical components on a computer system having a graphics operating system running one or more application programs, each application capable of requesting a connection to a control module, theme management The system includes: a first control module, having one or more first functions that respond to application program interface calls, and the calls can provide graphic components with themes; a second control module, having one or more first functions that respond to application program interface calls A function that is invoked to provide a graphical component without a theme; and a junction module that responds to a request to provide a graphical component by determining whether to link the application to one of the first control module or the second control module.

According to the present invention, there is also provided a theme management system, which is configured to provide graphics components on a computer system, the computer system has a graphics operating system running one or more application programs, and the theme management system includes: an intercepting abnormal branch module, which intercepts A provide message to a target window that has a non-client graphical component that requests the target window to provide a non-client graphical component of the target window; a theme management module that has a non-client graphical component capable of providing any window that uses a theme or a plurality of first functions; a routing module, which routes the offer message to one or more first functions of the theme management module, so that the non-client graphical component of the target window is provided using a theme with a set of theme properties; the first The control module has one or more second functions capable of interacting with the one or more first functions of the theme management module to provide user controls or shell public controls with theme characteristics; the second control module has the ability to provide one or more third functions of the user control of the feature and the shell common control; and a junction module that responds to a request from an application for the application to connect to one of the first control module or the second control module.

According to the present invention, there is also provided a method of providing graphical controls on a computer display of a computer having a graphical operating system, a first set of application programs implementing theme capabilities and a second set of application programs not implementing theme capabilities, the method comprising: providing a second set of application programs A control module having one or more first functions capable of providing graphical controls for applications not implementing theme capabilities; providing a second control module having graphical controls capable of providing applications implementing theme capabilities one or more second functions of; receiving a request from the application that the application should be connected to one of the first control module and the second control module; determining whether the application implements the theme capability; and if the application implements the theme The capability connects the application program to the second control module, so that the application program can use the functions of the second control module to provide a graphical control with a theme.

The present invention reduces application compatibility risks and is faster than previous methods. In addition to isolating controls from rendering techniques, the present invention also provides isolating controls from a single theme. The present invention allows the user to select the user's favorite theme from various different themes, and enhances the user's computing experience.

Additional advantages and novel features of the invention will be set forth in the description which follows, and in part will become apparent to those skilled in the art upon examination, or may be learned from practice of the invention.

Description of drawings

Fig. 1 is a schematic diagram representing the structure used in the present invention;

Figure 2 represents a suitable computing system environment for implementing the present invention;

Figure 3 is an example representing graphical components with different theme appearances;

Fig. 4 is a flowchart showing the operation of the junction processing;

FIG. 5 is an operational flow diagram representing an exemplary process of theme composition widgets;

Fig. 6 is a schematic diagram showing the structure of a subject file;

Fig. 7 is a flowchart showing the application of the present invention by an application program requesting a graphical component.

Detailed ways

In one embodiment of the invention shown in FIG. 1, the operating system is a graphical operating system having graphical display controls and components associated therewith. These controls include, but are not limited to items such as scroll bars, buttons, and sliders. Other controls are within the scope of the invention and are known to those skilled in the art. Other graphical display components are also within the scope of the invention. These components include, but are by no means limited to: non-client portions of windows in the display, such as window frames around application display on the user interface, minimize frames, and close frames.

In Fig. 1, the basic structure used in the embodiment of the present invention is shown. If the reader is already familiar with the operation of the subject composition system due to familiarity with the above-mentioned related patent applications, the reader is advised to proceed to the description of FIGS. the embodiment. The structure is illustrated by example application programs 138 and 139 , which are open and run on computer 110 . As an application such as APPI 138 is running, it often requires controls or graphical components to be presented or displayed on monitor 191 of computer 110 .

In FIG. 1 , libraries 208 , 210 and 212 are connected to applications 138 and 139 through junction module 214 . The meeting point module 214 enables theming of controls in an application to request a themable version of the control without requiring changes to the application itself. By using the manifest 215, the junction module 214 enables the applications 138 and 139 to load a specific version of the DLL 208, 210 or 212 at runtime. The Rendezvous Display Manifest 215 specifies the environment in which the application is to run, which allows multiple DLL versions to exist on one machine. Thus, the junction display manifest 214 will map the request for the component so that it is provided as a thematicable unit in the DLL 212 instead of the non-thematicable unit from the DLL 208 . This allows existing applications to be themable without changing the application's code. The junction display manifest 214 also allows new thematic controls to be placed in a different DLL from existing DLLs, which simplifies implementation and minimizes compatibility hazards.

Figure 2 shows an example of a suitable computing system environment 100 on which the present invention may be implemented. Computing system environment 100 is only one example of a suitable computing system environment and is not intended to be used with any limitation as to the scope of use or functionality of the invention. Neither should the computing environment 100 be interpreted as having any dependency nor requirement related to any one or combination of components illustrated in the exemplary operating environment 100 .

The invention is operational with numerous other general purpose or special purpose computing system environments or architectures. Examples of well-known computing systems, environments, and/or architectures that may be suitable for use with the present invention include, but are not limited to, personal computers, server computers, handheld or laptop devices, multiprocessor systems, microprocessor-based systems, set-top Boxes, programmable consumer electronic devices, network PCs, minicomputers, mainframe computers, distributed computing environments including any of the above systems or devices, etc.

The invention may be described in plain text of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc., that perform particular tasks or implement particular abstract data types. The invention also has utility in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media including memory storage devices.

Referring to FIG. 2 , an exemplary system for implementing the present invention includes a general purpose computing device in the form of computer 110 . Components of computer 110 may include, but are not limited to, processing unit 120 , system memory 130 , and system bus 121 coupling various system components including system memory to processing unit 120 . System bus 121 may be any of several types of bus structures including a memory bus, or memory controller, a peripheral bus, and a local bus using any of a variety of bus structures. By way of example and not limitation, such architectures include the Industry Standard Architecture (ISA) bus, the Micro Channel Architecture (MCA) bus, the Enhanced ISA (EISA) bus, the Video Electronics Standards Association (VESA) local bus, and also known as the Mezzanine bus Peripheral Component Interconnect (PCI) bus.

Computer 110 typically includes various computer readable media. Computer readable media can be any available media that can be accessed by computer 110 and includes both volatile and nonvolatile media, removable and non-removable media. By way of example, and not limitation, computer readable media may comprise computer storage media and communication media. Computer storage media includes volatile and nonvolatile media, removable and non-removable media, implemented by any method or technology for storage of information including, for example, computer readable instructions, data structures, program modules or other data. Computer storage media include, but are not limited to: RAM, ROM, EEPROM, flash memory or other storage technology, CD-ROM, digital versatile disk (DVD) or other optical disk storage, magnetic tape cartridges, magnetic tape, magnetic disk storage or other magnetic storage devices, Or any other medium that can be used to store desired information and that can be accessed with computer 110 . Communication media typically embody computer readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism, and include any information delivery media. The term "modulated data signal" means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as voice, RF, infrared and other wireless media. Combinations of any of the above should also be included within the scope of computer readable media.

System memory 130 includes computer storage media in the form of volatile and/or nonvolatile memory such as read only memory (ROM) 131 and random access memory (RAM) 132 . A basic input/output system 133 (BIOS), which contains the basic routines that help transfer information between units within the computer 110, such as at start-up, is typically stored in ROM 131 . RAM 132 generally contains data and/or program modules that are immediately accessible to and/or immediately operable by processing unit 120 . By way of example and not limitation, FIG. 2 shows operating system 134 , application programs 138 and 139 , other program modules 136 and program data 137 .

Computer 110 may also include other removable/non-removable, volatile/nonvolatile computer storage media. By way of example only, FIG. 2 shows a hard disk drive 140, which reads from or writes to a removable non-volatile magnetic medium; a magnetic disk drive 151, which reads or writes from a removable non-volatile magnetic disk 152; and an optical disk. Drive 155, which reads from or writes to a removable non-volatile optical disc 156, such as a CD ROM or other optical media. Other removable/non-removable volatile/nonvolatile computer storage media that can be used in the exemplary operating environment include, but are not limited to, magnetic tape cartridges, flash memory cards, digital versatile disks, digital video tapes, solid state RAM, solid state ROM, etc. Hard disk drive 141 is typically connected to system bus 121 through a non-removable storage interface, such as interface 140 , and magnetic disk drive 151 and optical disk drive 155 are typically connected to system bus 121 through a removable storage interface, such as interface 150 .

The drives described above and shown in FIG. 2 and their associated computer storage media provide storage of computer readable instructions, data structures, program modules and other data for the computer 110 . For example in FIG. 2 , hard disk drive 141 is shown as storing operating system 144 , application programs 145 , other program modules 146 and program data 147 . Note that these components are not the same as or different from operating system 134 , application programs 138 and 139 , other program modules 136 and program data 137 . Operating system 144, application programs 145, other program modules 146 and program data 147 are given different numbers here to illustrate that at least they are different copies. A user may enter commands and information into computer 110 through input devices such as a keyboard 162 and pointing device 161, commonly referred to as a mouse, trackball or touch pad. Other input devices (not shown) may include microphones, joysticks, game pads, satellite dishes, scanners, and the like. These input devices are often connected to processing unit 120 through user input interface 160 coupled to the system bus, but may also be connected through other interfaces and bus structures such as parallel port, game port or universal serial bus (USB). A monitor 191 or other type of display device may also be connected to system bus 121 via an interface such as video interface 190 . In addition to the monitor, the computer may also include other peripheral output devices, such as speakers 197 and a printer 196 , which may be connected through the output peripheral interface 195 .

Computer 110 may operate in a networked environment using logical connections to one or more remote computers, such as remote computer 180 . Remote computer 180 may be a personal computer, server, router, network PC, equivalent entity or other public network node, and generally includes many or all of the elements described above with respect to computer 110, although only memory storage device 181 has been shown in FIG. . The logical connections depicted in Figure 2 include a local area network (LAN) 171 and a wide area network (WAN) 173, but other networks may also be included. Such networking environments are commonplace in offices, enterprise computer networks, intranets and the Internet.

When used in a LAN networked environment, the computer 110 is connected to a LAN 171 through a network interface or adapter 170 . When used in a WAN networked environment, computer 110 typically includes a modem 172 or other means for establishing communications over WAN 173, such as the Internet. Modem 172, which may be internal or external, is connected to system bus 121 via user input interface 160 or other suitable mechanism. In a networked environment, program modules depicted relative to the computer 110, or portions thereof, may be stored in the remote memory storage device. By way of example and not limitation, FIG. 2 shows remote application 185 as resident on memory device 181 . It will be appreciated that the network connections shown are exemplary and other means of establishing a communications link between the computers may be used.

Although many other internal components of computer 110 are not shown, those of ordinary skill in the art will understand that these components and interconnections are well known. Accordingly, additional details relating to the internal structure of computer 110 will not be disclosed in connection with the present invention.

Those skilled in the art will appreciate that program modules such as operating system 134, application programs 138 and 139, and data 137 are provided to computer 110 via a memory storage device, which may include ROM 131, RAM 132, hard drive 141, magnetic disk drive 151 Or an optical drive 155 . Hard drive 141 is preferably used to store data 137 and programs, including operating system 134 and application programs 138 and 139 .

BIOS 133 stored in ROM 131 instructs processing unit 120 to load an operating system from hard disk drive 141 into RAM 132 when computer 110 is turned on or reset. Once operating system 144 is loaded into RAM 132 , processing unit 120 executes the operating system code and causes video elements associated with the user interface of operating system 134 to be displayed on monitor 191 . When an application program such as application program 138 is opened by a user, program code and related data are read from hard drive 141 and stored in RAM 192 .

Fig. 3 shows display examples of graphic parts having various appearances. As shown in FIG. 3 , the controls may take the form of an OK button 200 , a Cancel button 202 and an Apply button 204 . The present invention allows the appearance of controls and other components to be visually changed to better suit the computer user's requirements. In addition to color and font selection, the present invention allows changing the appearance of controls. For example, the configuration of widget components can be defined as required. For example, a scroll bar could be given up and down arrows that are close to each other at the bottom of the scroll bar, instead of an up arrow and up and down arrows at the bottom. Furthermore, the shape of the control and its components can be defined. As shown in FIG. 3, for each button 200, 202 and 204, four different overall appearances are shown. Each set of different appearances is coordinated and called a "theme". Each topic is represented by a row of buttons in Figure 3. Although only four themes are shown in FIG. 3, a computer user may choose to create an infinite number of themes. A theme is a collection or group of relatively specific objects or appearance features of a desired visual environment. As described below, the present invention allows a computer user to specify which of a number of predefined themes is to be applied to the controls and other components of the video display. Furthermore, the present invention allows new video themes to be added to the system without requiring changes to the software code of the controls and other graphical components. In addition, the invention allows the addition of new rendering techniques or the improvement of existing rendering techniques without changing the software code of controls and other graphical components.

As an application program, such as APP2 139 in FIG. 1 , running it often requires rendering or displaying controls or graphical components on the monitor 191 of the computer 110. For example, referring to FIG. 3, the display of the OK button 200 may be required by an application on the monitor. Application 139 requests that an instance of button 200 be created. According to this, the operating system passes class messages to the control instructing it to draw itself. This request will be routed to the dynamic link library (DLL) that contains the particular control. As an example, the DLL in the Windows operating environment is called User32.dll or ComCtl32.dll (V5), which are indicated as 208 and 210 in FIG. 1, respectively. Libraries 208 and 210 reside within graphics operating system 134 . Libraries 208 and 210 are typically linked by default with application 139 . As will be explained later, the connection of libraries 208 and 210 can be prioritized through the use of a fusion point 214 (fusion). The controls defined in libraries 208 and 210 contain the drawing code needed to render the controls on the monitor. Therefore, to change the appearance of controls in libraries 208 and 210, for each control in libraries 208 and 210, the software's drawing code must be changed.

The add-on library DLL, shown at 212 in FIG. 1 , is similar to library 210 in that it contains a number of predefined controls and graphics components 185 that can be used by application program 138 . Broadly speaking, DLL 212 contains several components that will be displayed graphically. However, in library 212, these controls are defined differently, making them "theme aware". In addition to containing all the software code needed to provide multi-video type controls, these controls are defined to have some basic information or values about the control, eg, the control's location, components and state.

The location is a location desired by the user on the user interface. Parts are the different items that make up the control. As an example, a scroll bar control has an elongated rectangular stem part, smaller thumb parts that slide within the stem part, and arrow parts on each end of the stem part. The state of a control describes the current appearance, which reflects the functional state of that part. For example, a button can be active, depressible, hot (when the mouse is over the control), blocked or inactive.

The controls in the DLL 212 also contain the drawing code needed to render the control if no theme is selected, and the theme awareness pathway through the code. DLL 212 requests rendering or drawing services from theme manager DLL 216 . Theme manager 216 provides request services and draws controls on the display's description site, with description parts in the description state.

Theme manager 216 contains a series of APIs that allow library 212 to interact and communicate with the theme manager. The API allows the author of the control to define the control within the DLL 212 as a series of parts and states without requiring the software to provide code. These APIs are generally divided into three types: drawing API 218 , information API 220 and utilization API 222 . The drawing API 218 is generally used in providing and assisting in the placement of required widget parts and other components. Information API 220 is generally used to obtain information about the currently defined appearance of a control, allowing controls to be individually styled. Utilizing APIs 222 are those APIs used by operating systems other than these controls to control theme selection. Utilization API 222 includes functions that can be used to list installed themes and load one of them.

Drawing API 218 is a collection of subject-aware drawing services. Each individual API in the drawing API 218 group is used to implement a different drawing service. Typically, each API requires specific components and states for nearby graphics components. An API called "DrawThemeBackground" is provided, which draws a border of a dedicated theme, and fills in a dedicated part and state at a desired location. Similarly, an API called "DrawThemeText" is provided that draws custom text using the colors and glyphs of a specific theme for specific parts and states.

As an example, if the OK button 200 (FIG. 3) is requested by the application 138, the control in the DLL 212 will pass the part, state and location information to the drawing API 218 through a function call such as DrawThemeBackground or DrawThemeText. As explained in more detail below, the part and status information is matched to the appearance features, and the theme manager 216 draws the controls on the monitor. The drawing API 218 also includes an API called "GetThemeBackgroundContentRect". This API enables the control to obtain the size of the content of the defined theme. Typically, this is the area within the bounding box or border. By using this API, the control can determine the available area within the background in which to place the item. When using this API, controls in DLL 212 request information about graphics components with specific components and states. This information is obtained through the theme manager 216 and returned to the control. A similar API called "GetThemeBackgroundExtent" is provided that calculates the size and location of a private theme for a specific widget and state given the extent of the content rectangle. This API can be used when the content is known, and based on the content, the outer boundaries for the theme need to be determined. Another API called "GetThemePartSize" is provided to retrieve the theme author, which is specified as the minimum and normal size of the control part.

The drawing API 218 also includes an API called "GetThemeTextExtent". When provided in a theme font, this API is used to calculate the size of specified text. So this API can be used to determine the width and height of a given text string. Thus, the author of the control can specify the parts and states that have text associated therewith, and use the API to obtain information from the theme manager 216 related to the size of the text string. Similarly, another API is available called "GetThemeTextMetrics" which can be used to obtain size information about glyphs used. Therefore, this API can be used to obtain information such as the width of the average font character. In other words, this API is used to obtain information from the theme manager 216 about the font size of the specific theme that the control needs.

An API called "GetThemeBackgroundRegion" is also provided in the drawing API 218 . In some operating systems, a region is a way of describing a non-rectangular shape. A region can also be thought of as an image with transparent parts. This API is used to compute regions for regular or partially transparent special theme backgrounds. In other words, the API can be used to determine what is transparent and what is opaque in the context of a window frame of dedicated parts and states. Therefore, the API supports the definition of non-rectangular shapes for controls and parts. Similarly, an API called "HitTestThemeBackground" is provided. This API is used to determine whether the point in the background of the specified part that was clicked is in a transparent or opaque area. This API is used by controls in DLL 212 to obtain information from theme manager 216 . If the click is in a transparent area, activation may not be required. Conversely, activation may be required if the tap is in an opaque area.

Another API included in the drawing API 218 is called "DrawThemeLine". This API enables themes to define a line of class types. This class type can be accessed and used for specific parts by calling the "DrawThemeLine" API. Similarly, an API called "DrawThemeBorder" is provided which allows a defined theme border to be customized. The subject boundary can be drawn as a dedicated part utilizing the API.

An API called "DrawThemelcon" is provided which allows defined theme icons to be rendered, possibly including special results for dedicated themes. For example, a themed icon may have a different appearance, such as a glowing appearance, when the mouse is directly over the icon.

The drawing API 218 also contains an API called "IsThemePartDefined" that can be used to determine whether a theme has defined parameters for specific parts and states. If the part is not defined within the theme, the control can draw the part itself. If the part has been defined by a theme, the theme manager 216 will provide the part according to the theme definition information. Another API called "IsThemeBackgroundPartiallyTransparent" is provided. This API is used to determine if the background is rectangular or an area with transparent parts. This API can be used to simplify the control code. If there is no transparency in the background, there is no need to do any hit testing by using the "HitTestThemeBackground" API.

Importantly, the drawing API 218 also includes an API called "OpenThemeData". This API is used to obtain a handle for a list of class names. A list of class names identifies a set of graphical components and can be divided into a parent class name and one or more child class names. For example, the parent class name could be Button. A subclass name for that parent class could be "Start Button". A handle is a reference to an internal structure that details various information and properties of an object. Theme manager 216 will search each class name in the list and use the first matching theme information it finds. For example, if the class name includes both Start Button and Button, then use the Start Button theme information if present. If the start button theme information does not exist, then the theme information for the button is used. If no value is found, legacy code will be used to provide the control. If any non-zero value is returned, a valid topic handle is established. This theme handle will be returned to DLL 212 and used for all theme drawing.

Similarly, another API provided is called "CloseThemeData". This API is used when a control is closed such as a button that is no longer needed or when the theme is changed, as explained in more detail later.

Another API provided is called "IsThemeActive". This API allows controls in the DLL 212 to obtain a true or false answer when the current theme is active. This API can thus be used to determine whether to call the "OpenThemeData" API or just use existing widgets to provide their own drawing code.

As mentioned above, theme manager 216 also includes a set of information APIs 220 . These information APIs 220 allow controls to be individually customized. In other words, these APIs are used in only some instances and can be used to obtain information about specific controls. These information APIs are used to query the theme manager 216 for defined theme information about specific characteristics of the theme. Accordingly, each API 220 requests information, which is provided by the theme manager 216 .

Within the information API 220 is an API called "GetThemeColor". This API utilizes a dedicated part with a unique color property identifier and a dedicated state to obtain information about the theme color. The property identifier is the desired color property number. In other words, the color API is used to request a color value corresponding to a desired characteristic, such as a background color. Another API called "GetThemeMetric" is provided that requests and receives a size value for a specific ThemeMetric. The size value will be an integer. An API called "GetThemeString" is also provided within the information API 220 . This API is used to obtain a string for a private property identifier. The string will include information about the number of characters in the string and where the string ends.

Another API is provided in a message API 220 called "GetThemeBool" which will return an integer that is either 0 or 1 for a given part, state and property. 0 and 1 correspond to a true or false state for that part, state and property. Another API provided is called "GetThemeInt". In a private state with a private property identifier, it will return an integer value for the private part. Similarly, an API called "GetThemeEnum Value" is provided which will return a theme enumeration for specific part, state and property identifiers. Topic enumerations are simply variables that support numeric values, which correspond to symbolic information. For example, an enumeration for calibration could be left, center, right corresponding to the numbers 0, 1, 2.

Another API called "GetThemePosition" is provided which will return two integer values corresponding to the x-position and y-position for a specific part in a specific state with a specific property identifier. Another API provided in the information API 220 is called "GetThemeFont". This API is used to obtain a logical specification of the glyph theme used for a given specific part, state, and feature identifier.

Yet another API provided in the information API 220 is called "GetThemeRect". The API will return four integers representing left, right, top, and bottom for specific part, state, and feature identifiers. Similarly, an API called "GetThemeMargins" is provided that will return four integers representing the left, right, top, and bottom margins for a given specific part, state, and feature identifier. There is also an API called "GetThemeIntList" which will return the value of a special feature as a list of integer values. Finally, an information API called "GetPropertyOrigin" is provided which returns the location where this property originated. This API allows the author of the control to obtain information about the origin of the property. In other words, this API allows the author of the control to determine whether the property is specific to a state, part, class, global, or a property not found. This is needed because theme properties are specified by theme authors in a hierarchical fashion. For example, if a property is not specific at the "Status" level, the Theme Manager will search the "Part" level, the "Class" level and finally the "Global" level for that property. Sometimes it is important for a control to know if the properties are clearly defined for the part/state it is handling. There is also an API called "GetThemeFilename" which returns a string value of a specific filename property.

Yet another API provided in the information API 220 is called "SetWindowTheme". This API allows the author of a control to change the control window to use a different set of theme information than its class would normally use. In other words, the API allows the use of a control while giving it a private view rather than the standard view defined by that class's theme. The API can take additional parameters to identify specific applications and class names. This allows theme authors to use a dedicated class but change the appearance of that class. For example, a button can be defined, which has a given button appearance. Using this API, the button can be changed to a different class name. For example, "OKButton" can be specified. Theme authors will then be able to use a class called "OKButton", and "OKButton" will have a different appearance than the standard button appearance.

There is also a subgroup of Themes Standard APIs within the Information API group similar to the Windows Standards, but dedicated to Themes. Unlike normal widget-based properties, these properties are available and shared by all widgets. "GetThemeSysColor" returns the theme-specific color value of the system-specific color index. "GetThemeSysColorBrush" returns a handle to a paint brush that is a dedicated system color indexed color. "GetThemeSysSize" returns the integer size of the dedicated theme size index. "GetThemeSysBool" returns a Boolean value (0 or 1) for a dedicated theme Boolean index. "GetThemeSysFont" returns the logical glyph structure for indexing dedicated theme fonts. "GetThemeSysString" returns the string value of the dedicated theme string index.

There are also some application-oriented APIs in the information API group 220 . "IsAppThemed" returns a Boolean value (0 or 1) indicating whether the application is themed by the operating system. "GetWindowTheme" returns the handle to the most recent theme, which was opened for a dedicated window if necessary. "GetThemeAppProperties" returns an indication that the control's widget and type are themeable in this application. "SetThemeAppProperties" allows the app to set these same flags.

Finally, there is an information API 220 for error handling. "GetThemeLastErrorCobtext" returns the error context (including error code, error code parameter, filename and source line) associated with the last reported theme error on the current execution table. "FormatThemeMessage" returns an error string for a specific error context in a specific language.

Theme manager 216 includes not only drawing API 218 and information API 220 but also a set of utilization APIs 222 . These APIs are used to achieve various results.

Drawing API 218 and Message API 220 allow authors or creators of controls in DLL 212 to define controls as a series of parts and states. Thus, the defined controls are extracted from the provisioning process of the theme manager 216, and are also extracted from theme definition appearance information or properties, as described in detail below. Using APIs 218 and 220 , authors of controls can create controls that are "theme aware" and setup for communication with theme manager 216 . This communication involves passing basic information or values to the theme manager 216 that allows the theme manager to provide the desired control, with the required components in the desired state.

Theme manager 216 also contains the providers needed to execute drawing commands. For example, a border fill provider 221 can be used, allowing different color themes to be applied to controls. As another example, a bitmap provider 223 can be used, which defines widget parts as images. Other examples of providers include using Vector Definition Language, Portable Network Graphics (PNG) files, or Portable Document Format files (PDF). It should be understood that the invention is not limited to a particular delivery technique. If a different provider is desired or needed, the theme manager 216 drawing code is modified to add that provider to the theme manager 216 . Therefore, controls in DLL 212 are separated or abstracted from rendering techniques in theme manager 216 . This allows different providers to be attached to theme manager 216 without modifying controls in DLL 212, as explained in detail below.

Providers in theme manager 216 provide the requested controls based on the appearance theme that has been selected by the computer user. For example, appearance themes 224 and 226 shown in FIG. 1 . As shown, topics 224 may be user topics and topics 226 may be business topics. However, it should be understood that other subject matter can be used and the invention is in no way limited to a particular subject matter. For example, other themes may include cartoon themes, children's themes or golf themes. As shown in FIG. 1 , business topic 226 has been selected by the user, as shown by solid line 228 . User topics 224 are optional, as indicated by dashed lines 230 .

Each topic 224 and 226 has a similar structure. As shown in FIG. 6 , business theme 226 includes a series of image files 232 . Image file 232 is an image file used by a particular theme. In this case, image file 232 is the image file used by business theme 226 . Commerce theme 226 also includes a themes.ini file 234 . File 234 is a text file and can be created in either the ANSI or UNICODE character set. File 234 specifies the color schemes obtained and the sizes available for this theme. In the case of the theme 226, the file 234 specifies the color scheme to obtain and the size at which the business theme 226 is available. Thus, file 234 represents all changes to the theme to which it applies.

The theme file 234 is made up of one or more sections. Sections within theme file 234 include Documentation section 236 , Size section 238 , Color Scheme section 240 and Documentation section 242 . Documentation section 236 is optional and may contain any property name. Size field 238 specifies a size name, such as "default size", "very small" or "large". The color scheme section 240 is used to specify a simple color scheme name and select color scheme transfers associated with that color scheme name. The file section 242 is used to specify the unique name of the class data file. File section 242 will include the file name, the color scheme to use for the file name (from color scheme section 240), and the sizes the file will support (from size section 238).

The theme 226 includes a second .ini file 244 marked in FIG. 6 . File 244 is a class data file that contains theme data for a particular size and color scheme. File 244 may also contain definition sections. For example, file 244 may contain global sections that define the properties of a particular class of controls. File 244 may also contain sections that allow access to and use of system standards. Finally, file 244 may contain a set of class segments. Each class segment name contains the class name, selected part name, and selected state name. Within this section are property/value pairs that define the appearance of a particular part or control. For example, the class name could be "slider" for a sliding control. The part specified for this slider is a "rail". The states defined for this rail part are "normal", "incapable" and "active". This type of section name can also include an application (or "group") name that specifies that the section only applies to a specific application (or "group" name, as specified by the SetWindowTheme API).

Image files 232 , theme files 234 , and include files 244 are broadly grouped together to form theme directories 246 . The theme directory 246 and system schema files located within the theme manager 216 are used to load the business theme 226 . The system schema file is the file that defines the property numbers for all properties contained in a particular theme and is basically the parent definition file that allows theme properties to be assigned a number corresponding to the defined look.

Thus, theme directory 246 contains theme .ini files 234, class data files 244 and all image files 232 used by the theme. The content of the theme directory 246 can be packaged into a DLL file by the theme packaging tool 250 . The theme packaging tool 250 processes the theme .ini file by analyzing the schema file for syntax errors and adding the .ini file to the package being built. The properties identified from the document segment are written to the package string table. Color scheme information from color scheme field 240 and size information from size field 238 are also written to the packstring table. Each class data file 244 is also processed. When a class data file is processed, the file is parsed for syntax errors in the program file. This type of data file is also added to the package being built.

The DLL files generated by theme packaging tool 250 are business theme files 226 . File 226 contains theme data, and the theme data is separated from widget repository 212 . This allows different themes to be created and selected without changing the controls defined in the library 212 . Therefore, control authors can create and define controls that have nothing to do with appearance or theme data. File 226 is in binary format and is passed to shared theme data file 252 when a computer user selects business theme 226, as shown in FIG. File 252 is a shared memory map file that can be accessed by all processes. Thus, when a theme is selected by a computer user, theme manager 216 will read the information for the defined theme file, such as file 226, and place that information in binary format in file 252, where all running processes can access that binary information.

As shown in FIG. 1 , a theme conversion control panel 254 is provided which communicates with the theme manager 216 . Pad 254, in conjunction with the user interface, displays available themes from which the user can choose. As shown in FIG. 1 , the control panel 254 will allow the user to select either the business theme 226 or the user theme 224 . As already discussed above, if the business theme 226 is selected, and the user switch of the computer selects the user theme 224, then the theme 224 will be loaded into the shared memory mapped file 252 as binary data. Theme manager 216 also sends each theme-aware control in DLL file 212 a message that the theme has changed. Each theme-aware control knows how to respond to this message.

When a theme-aware control receives a message that the theme has changed, the control will close the current theme handle received via the OpenThemeData API. The control will then attempt to open a new theme handle, again using the OpenThemeData API. If the new theme handle cannot be opened, the control knows that the theme has been turned off for that control, and the old drawing code will be used by the control to draw itself. If a new theme handle is opened, theme manager 216 will look at the theme binary data and start a new drawing routine so that all theme-aware controls are redrawn using the newly selected theme, such as user theme 224. Any cached information about previously selected topics is invalidated, and that information must be recalculated.

In operation, as shown in FIG. 7 , the application 138 or 139 will request a graphic, such as a control, to be provided on the user interface, as indicated at 256 . The graphics request is routed through the rendezvous point 214 . As indicated at 258, the junction processing will determine whether the requested control is a theme-aware control. If the requested control is not theme aware then the old code is used and the control will draw itself using the control from the DLL 208 or 210 as shown at 260 in FIG. 7 . If the requested control is theme-aware, the graphics request is processed in DLL 212, as shown at 262. In request servicing, using APIs 218, 220, and 222, controls in DLL 212 pass basic information for a graphics request to theme manager 216, such as the part, state and location for the requesting control. Thus, in the case of an application that does not have the appearance characteristics found by theme manager 216 , graphics requests are handled in DLL 212 . Theme manager 216 will then determine or apply theme-specific skin properties for that given widget part and state, as shown at 264 . The appearance data is retrieved from the shared memory mapped data file 252 . Using the retrieved appearance data, the theme manager will provide the control on the computer display, as shown at 266, along with the location for the requested control part and state.

Referring to FIG. 4, another embodiment of logical operations implemented with the junction 214 (FIG. 1) is illustrated. In this embodiment, rendezvous point operations are performed when an application is loaded rather than a routine application as in FIG. 7 via a rendezvous request. Rendezvous allows older unthemed applications to work in a themed environment by connecting older unthemed controls to older applications. Older unthemed controls are shipped as User32.dll and ComCtl32.dll Version 5 (V5). User32.dll provides user controls such as buttons, scroll bars, and list boxes. ComCtl32.dll provides shell common controls such as toolbars, list views, and tree views. Junction 214 links the theme control file ComCtl32.dll version 6 (V6) to new applications that have been developed and tested in the theme environment.

The operational flow in Figure 4 begins with a load operation 402, in which an application starts running on the system. The part of the startup process is the dynamic connection of the control library. Linking is the process of associating references between program modules and libraries of subroutines to create load modules that are ready to run on a computer. After the load operation 402, control transitions to a display manifest detection operation 404, where it is determined whether the application has a display manifest associated therewith. If the manifest is not displayed, control transfers to link operation 406, where the legacy controls User32.dll and ComCtl32.dll V5 are linked into the application's memory map. As mentioned earlier, traditional controls are not theme-aware.

On the other hand, if there is a display list such as display list 215 in display list detection operation 404, then control transfers to theme module search operation 408, wherein it is determined whether ComCtl32.dll V6 is listed in the display list. If the display list does not list ComCtl32.dll V6, then control transfers to link operation 406, where the traditional controls are linked into the memory map of the application. On the other hand, if ComCtl32.dll V6 is listed in this display manifest, then transfer control to connect operation 410, wherein the theme awareness control of ComCtl32.dll V6 is connected in the storage map of the application program.

5 is an operational flow diagram illustrating an exemplary process for theming non-client widgets in a theme-aware application environment. Figure 5 depicts how non-client widgets can be provided with two general case theme properties. The first case is where a non-client window message, such as non-client window message 502, is directed to a window. The second case is when an application asks for a non-client window area when it makes API calls that can affect the non-client window area of the window.

In the first case, the non-client area of the target window may need to be provided when the non-client window message 502 is generated. The non-client area of a window typically has one or more non-client graphical components, such as minimize boxes, window frames, and close boxes. A non-client window message 502 can be any message sent to a window, including but not limited to measurement or provide messages. For example, when a computer user resizes a target window, a non-client window message 502 is sent to the window requesting that the window should be re-rendered at the new size. Non-client window messages 502 are typically received by applications that use a target window such as APP2139. Based on the non-client window message 502, an application such as APP2 139 can be activated, for example, to adjust the appearance of its GUI. The non-client window message 502 is then intercepted by the UserAPIHook 506, which routes the message to the theme manager 216. UserAPIHook 506 may be part of Theme Manager 216. Theme manager 216 interprets non-client window messages 502 . Based on the non-client window message 502, the theme manager 216 can make measurements about the size of the non-client widget and can use the theme properties in the shared theme data 252 to provide the non-client area of the window.

Continuing the example of FIG. 5, when an application such as APP2 139 or a control of an application makes an API call, the result can affect the non-client area of the window. In this case, the non-client window area can be re-rendered using the theme properties. For a subject-aware application, such as application 139, an API call such as API call 503 may constitute USER32 208. API call 503 may be any API call, including but not limited to any API function discussed previously. For example, the "MoveWindow()" API call can change the window's size, position and z-ordering, which requires redrawing the window frame. When the subject is active, the USER32 208 routes the API call 503 to the UserAPIHook 506 when receiving the API call 503 . UserAPIHook 506 then routes API calls 503 to Topic Manager 216. Theme manager 216 interprets API calls 503 and performs measurement calculations related to the size of the window frame. Theme manager 216 then uses shared theme data 252 to provide non-client window regions with theme properties, if desired.

In the embodiment of FIG. 5, USER32 208 operates non-client APIs and messages for both a subject application, such as APPI 138 of FIG. 1, and a non-theme application, such as APP2 139, as shown in FIG. The message flow shown in Figure 5 is the same for non-topic and topic applications. Thus, non-client graphical components of windows are themed regardless of whether the application is theme-aware.

Importantly, UserAPIHook operation 506 modifies the render request to theme manager 216, which can use shared theme data 252 to render the non-client area of the window with theme properties. As discussed earlier, for widgets, theme property data can be easily attached by adding properties to the ".msstyles" file. This allows a large number of themes for non-client widgets without changing the control software.

The logical operations of various embodiments of the invention are implemented as (1) a series of computer-implemented activities or program modules running on a computing system and/or (2) machine logic circuits or circuit modules interconnected in a computing system. The implementation is a matter of choice, depending on the performance requirements of the computing system implementing the invention. Therefore, the logical operations constituting the embodiments of the present invention to be described herein are referred to variously as operations, structural means, activities or modules. Those skilled in the art can realize that these operations, structural devices, activities and modules can be implemented in software, hardware, special purpose digital logic and any combination thereof without departing from the spirit and scope of the present invention defined in the appended claims .

Alternative embodiments of the present invention will become apparent to those skilled in the art from the review, including the description of the figures. Accordingly, the scope of the invention is defined by the appended claims rather than the foregoing description.

Although the invention has been described in language specific to computer structural features, methodological functions, and computer-readable media, it should be understood that the invention as defined in the appended claims is not necessarily limited to the specific described structural, functional or media. As an example, other decision methods may be included in the junction processing in conjunction with the control providing module. Accordingly, the dedicated structural features, acts and mediums serve as exemplary embodiments for implementing the claimed invention.

The above various embodiments are provided for convenience of description, and should not be construed as limiting the present invention. Those skilled in the art will readily recognize various modifications and changes that constitute the present invention without following the example embodiments and applications illustrated and described herein, and without departing from the true spirit and nature of the invention as set forth in the following claims. scope.

Claims (17)

1. a theme management system constitutes graphics part is provided on computer system, and this computer system has the Graphic Operating System of the one or more application programs of operation, and each application program can ask to be connected to control module, and theme management system comprises:

First control module has first function that one or more response application program interfaces call, and this calls can provide the graphics part with theme;

Second control module has second function that one or more response application program interfaces call, and this calls can provide the graphics part that does not have theme; With

It is individual upward so that the request of graphics part to be provided that point module, its response determine that this application program is connected to one of first control module or second control module.

2. the theme management system of claim 1 also comprises the Subject Manager module, and it has response provides one or more the 3rd functions that call from one or more first functions of first control module, and the 3rd function can provide the graphics part that uses theme.

3. the theme management system of claim 2 also comprises:

Intercept unusual branch module, its intercepting is sent to the non-client window message of target window, this target window has the one or more non-client's graphics part in non-client window zone, and non-client window message request target window is finished the effect on one or more non-client's graphics parts; With

First routing module, it receives non-client window message and non-client window message is routed on one or more the 3rd functions of theme manager, so that finish this effect from intercept unusual branch module.

4. the theme management system of claim 3, wherein first control module also comprises second routing module, it calls Application Program Interface and is routed to intercepting unusual branch module, can finish effect so that the response application program interface is invoked on one or more non-client's image parts on the non-client window zone.

5. the theme management system of claim 3, wherein second control module also comprises the 3rd routing module, it calls Application Program Interface and is routed to intercepting unusual branch module, can finish effect so that the response application program interface is invoked on one or more non-client's image parts on the non-client window zone.

6. the theme management system of claim 3, wherein non-client window message is a kind of giving information, its request should be provided at the one or more non-client's image parts on the non-client window zone, and the Subject Manager module gives information by the unit response of one or more non-client's image is provided.

7. the theme management system of claim 3, each of wherein one or more non-client's image parts is relevant with size, non-client window message is a kind of measurement message, its request should be measured the size of the one or more non-client's image parts on non-client window zone, and the Subject Manager module is by measuring the size response measurement message of one or more non-client's image parts.

8. the theme management system of claim 1, wherein first and second functions of first and second control module can provide user control and the public control of shell.

9. the theme management system of claim 1, wherein the point module comprises first detection module, its detect whether application program have one group of control module of expression which should be connected to the relevant demonstration inventory file of this application program;

Second detection module, it detects and shows whether inventory represents that first control module should be connected; With

Link block represents that first control module should be connected if show inventory, and it is connected to application program with first control module.

10. a theme management system constitutes graphics part is provided on computer system, and this computer system has the Graphic Operating System of the one or more application programs of operation, and theme management system comprises:

Intercept unusual branch module, it is truncated to giving information of target window, and this target window has non-client's graphics part, and this request target window that gives information provides non-client's graphics part of target window;

The Subject Manager module, it has one or more first functions of non-client's graphics part that any window that uses theme can be provided;

Routing module, it will give information and be routed on one or more first functions of Subject Manager module, so that use the theme with one group of theme characteristic that non-client's graphics part of target window is provided;

First control module, have can with mutual one or more second functions of one or more first functions of Subject Manager module, so that user control or the public control of shell with theme characteristic to be provided;

Second control module, having to provide the user control that do not have the theme characteristic and one or more the 3rd functions of the public control of shell; With

Point module, its response from the request of application program so that this application program is connected on one of first control module or second control module.

11. the method that graphical control is provided on the graphoscope of the computing machine with Graphic Operating System, first group of application program realizes the theme ability, and second group of application program do not realize the theme ability, and this method comprises:

First control module is provided, and it has one or more first functions of the graphical control of the application program that can be provided for not realizing the theme ability;

Second control module is provided, and it has one or more second functions of the graphical control of the application program that can be provided for realizing the theme ability;

Reception is from the request of application program, and request applications should be connected on one of first control module and second control module;

Determine whether application program realizes the theme ability; With

If application program realizes the theme ability then application program is connected on second control module, makes application program can use the function of second control module that the graphical control with theme is provided.

12. the method for claim 11 also comprises:

Receive Application Program Interface and call from application program, the Application Program Interface call request provides graphical control;

Determine whether graphical control realizes the theme ability; With

If graphical control is realized the theme ability, call theme manager, its use has the subject document of graphics part performance data so that the graphical control of being asked to be provided with subject manner.

13. the method for claim 11 determines that wherein effect comprises:

Whether detection exists the demonstration inventory for application program; With

Search is used for the demonstration inventory of indicator, this indicator represent application program can with second control module alternately so that the graphical control with theme to be provided.

14. the method for claim 12 also comprises:

Intercepting is sent to the non-client window message of the window with one or more non-client's graphics parts, and this non-client window message request window is finished the effect on one or more non-client's graphics parts;

Non-client window message is routed to theme manager, the theme characteristic of the non-client's graphics part of this Subject Manager management; With

Finish the effect on one or more non-client's graphics parts.

15. the method for claim 14, wherein non-client window message is a kind of giving information, and effect provides one or more non-client's graphics parts.

16. the method for claim 14, wherein non-client window message is a kind of measurement message, and each of one or more non-client's graphics parts is relevant with size, and effect is a size of measuring one or more non-client's graphics parts.

17. the method for claim 12 also comprises:

Application Program Interface called be routed to intercepting unusual branch module;

Application Program Interface called be routed to theme manager, theme manager provides non-client's graphics part with the theme form;

Determine the one or more non-client's graphics part whether Application Program Interface calls influences the window that is used by application program; With

If Application Program Interface calls the one or more non-client's graphics parts of influence, then provide one or more non-client's graphics parts with the theme form.

Images