Font changing method performed by computing device, and computing device performing same

Abstract

The present invention relates to a font changing method of a computing device. According to the present invention, a font changing method performed by a computing device comprises the steps of: receiving an input of a user's font change request; on the basis of the input font change request, requesting a change of an existing font to a desired new font; along with the request for the change to the new font, requesting a change of a font size of the existing font to a new size within a predetermined range; and in response to the requests, changing the existing font to the new font according to the new size. The present invention solves a problem that font style and size are not consistently applied in various applications installed in a smartphone. By inducing an application to follow font settings of an operating system, a user can use all applications in one unified font environment. Accordingly, consistency of an interface can be maintained and design integration can be increased.

Description

Method for changing fonts performed on a computing device and a computing device performing the same

[0001] The present invention relates to a method for changing a font of a computing device.

[0002] Fonts on smartphones play a crucial role in usability and accessibility. They make text easier to read on small screens, and visual aesthetics and brand identity are also significantly influenced by fonts.

[0003] The prior art (Korean Patent Publication No. 10-2016-0115081 (October 6, 2016)) relates to a method for automatically adjusting the font and image size of a device based on the user's age, gender, preference, and individual eyesight information, and proposes a method for adjusting the font and image size based on the user's information (age, gender, eyesight, etc.).

[0004] The smartphone's operating system (OS) manages overall font settings, but even if you request a font change through the OS, the font change may not be reflected immediately depending on the application.

[0005] Some applications do not reflect changes to the system font in real time, but instead maintain the previous font settings until the application is restarted.

[0006] This means that users may need to force quit or reboot the application for the changed font to take effect. Additionally, depending on the device, a system reboot may be required after changing the font.

[0007] This means that font settings may not be consistently applied depending on the application's operating conditions. Users may experience inconvenience if they are unable to change fonts across applications or if font changes are not properly reflected. Furthermore, inconsistencies in font changes can hinder the overall usability of smartphones.

[0008] The purpose of the present invention is to propose a method for solving the problem of fonts not being consistently changed depending on the characteristics of applications installed on a smartphone.

[0009] To this end, the present invention allows for a consistent application of a font set in an operating system (OS) even in a specific application by inducing a change in font size arbitrarily as well as a change in the font itself.

[0010] The present invention reflects the characteristics of the operating system and allows the overall system font to be changed through a font size adjustment mechanism with minimal additional development.

[0011] The present invention particularly aims to provide an environment in which user settings are consistently reflected by resolving compatibility issues between operating systems and applications.

[0012] An additional objective of the present invention is to minimize inconvenience in user convenience by ensuring that font size changes are made within a range that is difficult for the user to perceive. This ensures that the application's font style matches the operating system's font settings, while ensuring that the user does not perceive any visual difference due to the change in font size.

[0013] Furthermore, the present invention aims to determine the range of font size changes by reflecting display characteristics, such as resolution, size, and pixel density. This allows for optimal font size adjustments for each display environment, thereby providing a consistent visual experience across displays.

[0014] A font changing method performed in a computing device according to the present invention for solving the above technical problem includes the steps of receiving a user's request for changing a font, requesting a change to a new font based on the input font change request, requesting a change to the font size of the existing font to a new size within a predetermined range along with the request for changing to the new font, and changing the existing font to a new font according to the new size according to the request.

[0015] The above predetermined range may be a unit smaller than the change unit set for the above font size.

[0016] The above predetermined range may be determined according to the display size of the computing device.

[0017] This may include a step of requesting that the new size be changed back to the existing font size.

[0018] The above font size is set in floating point format, and the predetermined range can be determined to change the size below the decimal point.

[0019] The above predetermined range may be determined such that the mantissa part is changed within a range in which the change of the exponent part defining the font size is limited.

[0020] A computing device according to the present invention for solving the above technical problem may be a computer device including a processor and a memory communicating with the processor, wherein the memory stores instructions for causing the processor to perform operations, and the operations include an operation of receiving a user's request for changing a font, an operation of requesting a change to a new font based on the input font change request, an operation of requesting a change to the font size of the existing font to a new size within a predetermined range together with the request for changing to the new font, and an operation of changing the existing font to a new font according to the new size in accordance with the request.

[0021] The above predetermined range may be a unit smaller than the change unit set for the above font size.

[0022] The above predetermined range may be determined according to the display size of the computing device.

[0023] This may include an action to request that the new size be re-converted to the existing font size.

[0024] The above font size is set in floating point format, and the predetermined range can be determined to change the size below the decimal point.

[0025] The above predetermined range may be determined such that the mantissa part is changed within a range in which the change of the exponent part defining the font size is limited.

[0026] The present invention addresses the problem of inconsistent application of font styles and sizes across various applications installed on smartphones. By ensuring that applications adhere to the operating system's font settings, user convenience can be enhanced.

[0027] The present invention minimizes visual confusion caused by font size changes by designing them to occur within a range difficult for users to perceive. By applying the changed font and size naturally and without inconvenience, user satisfaction is enhanced.

[0028] The present invention adjusts font size based on display characteristics, such as resolution, size, and pixel density, thereby applying the optimal font size and visual effects for each device. This provides optimal readability tailored to the display environment.

[0029] The present invention not only automatically optimizes font and image sizes and presents them to the user, but also includes the ability for the user to manually select or save them, providing a personalized environment for each user. This allows for customized settings tailored to individual needs and increases user control flexibility.

[0030] Figure 1 is an exemplary diagram showing the implementation of a system according to one embodiment of the present invention.

[0031] Figure 2 is a flowchart illustrating a font change method according to one embodiment of the present invention.

[0032] FIG. 3 is a diagram showing a process of installing a font from a server to a user terminal according to one embodiment of the present invention.

[0033] FIG. 4 is a diagram showing an example of applying a font size arbitrarily changed to an application on a user terminal according to one embodiment of the present invention.

[0034] FIG. 5 is a diagram showing operations in individual applications when the font size is changed according to one embodiment of the present invention.

[0035] FIG. 6 is a flowchart illustrating a process of readjusting the size of an arbitrarily changed font according to one embodiment of the present invention.

[0036] FIG. 7 is an exemplary diagram showing the implementation of a server as a computing device according to the present embodiment.

[0037] The following merely exemplifies the principles of the invention. Therefore, those skilled in the art will be able to implement the principles of the invention and invent various devices within the scope and spirit of the invention, even if not explicitly described or illustrated herein. Furthermore, all conditional terms and embodiments listed herein are expressly intended, in principle, to facilitate understanding of the invention, and are not intended to be limiting to the specifically enumerated embodiments and conditions.

[0038] The above-described purposes, features and advantages will become clearer through the following detailed description with reference to the attached drawings, so that a person having ordinary skill in the art to which the invention pertains can easily practice the technical idea of ​​the invention.

[0039] Furthermore, when describing the invention, detailed descriptions of known technologies related to the invention will be omitted if they are deemed to unnecessarily obscure the gist of the invention. Below, preferred embodiments of the present invention will be described in detail with reference to the attached drawings.

[0040] Figure 1 is an exemplary diagram showing the implementation of a system according to one embodiment of the present invention.

[0041] Referring to FIG. 1, a system for carrying out the present invention is composed of a user (100) requesting a font change, a server (200) providing a font file according to the request of the user (100), and a user terminal (300) that distributes and installs the font file and changes the font according to the request of the user (100).

[0042] When a user (100) wants to change the font on a smartphone or other terminal, he / she requests a change in font style and size through the settings menu or application of the terminal.

[0043] A user (100) can select a desired font from among various fonts provided by the user terminal (300) itself or the font-providing server (200), and after selection, can check the changed font style and size. If necessary, the changed font can be reviewed in advance through the font preview function and a decision can be made as to whether to apply it.

[0044] The server (200) serves to provide font files upon request from a user (100). The server (200) stores various font files and provides the font files requested by the user (100) in an appropriate format for each operating system (OS). For example, when different OSs are used, such as smartphones, tablets, smart TVs, and automotive displays, font files compatible with the respective OSs are distributed.

[0045] The server (200) serves to provide and manage font files. This server (200) may be a simple individual font provisioning server (200), but may also be implemented as a platform such as the App Store or Google Play Store. Since these platforms manage the distribution of various applications and services, they provide an appropriate infrastructure for efficiently handling the distribution and updates of font files.

[0046] The App Store and Google Play Store are platforms that centrally manage and distribute all resources related to mobile applications. These stores can provide not only applications but also user interface-related files, such as font files, icon packs, and themes. Therefore, in the present invention, when a font change request is made, a platform such as the App Store or Android Store can serve as a server (200) that stores and distributes the font files.

[0047] The server (200) can provide optimized font files for various operating system (OS) environments. For example, the server (200) can be equipped with a system that recognizes the differences between iOS and Android and distributes font files suitable for each operating system. This allows the user (100) to receive the optimal font files for each operating system and easily install and apply them on their device.

[0048] The server (200) can distribute new font files or changes to users (100) in real time through an automatic update function. In addition, when a user (100) uses multiple devices with the same account, font settings can be automatically synchronized to provide consistent usability.

[0049] The server (200) strictly manages security protocols related to applications, thereby minimizing security threats during the distribution and installation of font files. By providing users (100) with stable and reliable font files, it also prevents device security issues.

[0050] When a user (100) requests to purchase or change a font on a user terminal (300) such as a smartphone, tablet, or smart TV, the user terminal (300) downloads the corresponding font file from the server (200) through a platform such as an app store or Android store.

[0051] The server (200) (App Store / Google Play Store) provides a font file that matches the user's (100) device information (operating system, resolution, display characteristics, etc.) and automatically installs and applies the same.

[0052] When a user (100) uses the same account on different devices, the store supports synchronizing font settings so that the same font style and size can be used on multiple devices.

[0053] The user terminal (300) receives and installs font files distributed from the server (200), and performs the role of applying the fonts according to a change request from the user (100). The user terminal (300) may include various devices in addition to a smartphone.

[0054] The smartphone downloads the font file provided from the server (200) and installs it in the system folder. When the user (100) requests a font change, the changed font is immediately applied through the OS settings menu.

[0055] On smartphones, font changes are applied in real time throughout the user (100) interface (UI), and the font size and style set by the user (100) are reflected in all applications.

[0056] Since tablet PCs have larger screens than smartphones, the font files provided by the server (200) are adjusted to fit the display size and resolution.

[0057] It is also possible to synchronize font settings between a tablet PC and a smartphone so that the same font environment is maintained on both devices when a user (100) logs in with the same account.

[0058] Alternatively, the user terminal (300) may be a smart TV. The server (200) may receive information on the user's (100) TV screen size and resolution, and provide an appropriate font size based on this.

[0059] The user terminal (300) includes an in-vehicle display and is used while driving, so readability and safety are important. The server (200) can provide a highly readable font based on the size and location information of the vehicle display.

[0060] In addition, when a smartphone is linked with a display in a car through linkage between user terminals (300) and displayed in a form such as CarPlay or Android Auto, the changed font can be synchronized with the smartphone.

[0061] This system consistently processes font change requests from various user terminals (300) and provides optimal font files tailored to the operating system and display characteristics, thereby providing unified usability across all terminals, including smartphones. This improves user (100) accessibility and allows for more flexible and immediate response to user (100) font settings requests.

[0062] Hereinafter, a method for changing a font according to the present invention will be described with reference to FIG. 2.

[0063] Figure 2 is a flowchart illustrating a font change method according to one embodiment of the present invention.

[0064] Referring to FIG. 2, the user terminal (300) receives a font change request from the user (100) (S100).

[0065] When a user (100) wishes to change the font on a smartphone, tablet PC, smart TV, or other terminal, he or she inputs a font change request through the UI (settings menu, accessibility options, etc.) of the device. At this stage, the user (100) can additionally select or input a desired font style (e.g., Gothic, Serif, etc.) and font size (e.g., small font, large font, etc.).

[0066] The user terminal (300) collects the font change request entered by the user (100) and prepares to process it.

[0067] At this time, a font file converted into a format suitable for the font style and operating system (OS) selected by the user (100) can be distributed from the server (200) and transmitted to the user terminal (300) in advance.

[0068] The user terminal (300) checks whether the font selected by the user (100) is suitable for the OS and device characteristics, and prepares in advance to apply it appropriately. At this time, files required for changing the font may be downloaded or installed.

[0069] FIG. 3 is a diagram showing a process of installing a font from a server (200) to a user terminal (300) according to one embodiment of the present invention.

[0070] Referring to FIG. 3, the user terminal (300) can receive a font file (e.g., “ABC Font apk”) from the server (200) and install it in a designated location ( / system / ABC / fonts / ) of the user terminal (300).

[0071] When a user (100) requests font installation on a smartphone or other terminal, the server (200) prepares the requested font file. The server (200) selects the ABC Font apk file from among several fonts pre-stored on the server (200) and prepares to transmit it to the user's (100) terminal.

[0072] The font file is downloaded through a network connection between the terminal and the server (200).

[0073] The user terminal (300) receives the ABC Font apk file from the server (200). The downloaded file is stored in a temporary path (e.g., / tmp / folder) or a specific installation preparation path.

[0074] Once the downloaded font file is saved, the user terminal (300) installs the font file in a specific directory of the user terminal (300), for example, / system / ABC / fonts / . During this process, the operating system may request appropriate permissions (such as root permissions) from the user (100).

[0075] Since the / system directory is a user terminal (300) folder, administrator (root) privileges may generally be required to install files here.

[0076] When the font file is successfully installed in the / system / ABC / fonts / folder, the user terminal (300) registers the font and prepares to use it.

[0077] The next user terminal (300) requests a change to a new font based on the input font change request (S200).

[0078] Based on the information requested by the user (100), a request is made to change the currently used font to a new font.

[0079] In this embodiment, the user terminal (300) requests a change to the new font and also requests a change to the font size of the existing font to a new size within a predetermined range (S300).

[0080] That is, in this embodiment, the user terminal (300) can increase the range of font changes by allowing a request for changing a font to be accompanied by a request for changing an arbitrary font size.

[0081] FIG. 4 is a diagram showing an example of applying a font size arbitrarily changed to an application on a user terminal (300) according to one embodiment of the present invention.

[0082] Referring to FIG. 4, the user terminal (300) can request the OS to change the font size to a new size (randomly or forcibly) regardless of the user's (100) intention.

[0083] Even if a user (100) requests a font change, the user terminal (300) automatically adjusts the font size within a predetermined range at the same time, thereby affecting the UI and application of the entire device.

[0084] Changing font size plays a crucial role in accessibility. Specifically, for users with poor eyesight (100) or visual limitations (100), the operating system provides a feature to improve text readability by adjusting font size. Because this feature is a powerful setting that affects the entire user terminal (300), when a user (100) changes the setting, the change is reflected in almost all applications.

[0085] Changing font size tends to have a broader impact than styles, as it affects many UI elements in an application, including interface layout, button sizes, and text field sizes.

[0086] While font style simply changes the shape or design of the text, font size has the effect of altering the layout and placement of UI elements. As the font size increases, the text takes up more space, and other UI elements are rearranged or resized accordingly.

[0087] Accordingly, the operating system may generally provide the ability to change the font size across the user terminal (300) through font size adjustment.

[0088] The operating system controls font size at the level of the entire user terminal (300). This means that when the font size is changed, the OS immediately applies the corresponding size to all UI elements, such as menus, settings screens, user terminal (300) notifications, and basic applications.

[0089] Since the font size setting affects the entire user terminal (300), most applications that operate based on this setting also follow the same font size.

[0090] That is, since adjusting the font size affects all applications, when the font size change command is combined with the font style change command, the font style can be consistently changed in all applications of the user terminal (300).

[0091] Font size setting operates as a basic function provided by the user terminal (300), and is implemented to mostly follow the font size setting even when the application uses a specific font.

[0092] FIG. 5 is a diagram showing operations in individual applications when the font size is changed according to one embodiment of the present invention.

[0093] Referring to Figure 5, font change requests and environment setting changes are detected.

[0094] When the user (100) or user terminal (300) environment changes in App 1, the handleConfigurationChanged() method in the ConfigurationController.java file is called. This method operates when the user (100) changes the environment settings or the user terminal (300) automatically detects an environment change. Here, the environment change may be a variety of changes in the user terminal (300), such as a font change request, a resolution change, or a theme change.

[0095] This method receives a Configuration object and a CompatibilityInfoCompat object as parameters, processes changed environment information within the user terminal (300), and calls a method called SandollTypeface.loadSystemFonts() to reload the user terminal (300) font.

[0096] The loadSystemFonts() method reloads font information within the user terminal (300) and loads a new font list that can be applied to the user terminal (300). This may be a default font of the user terminal (300) or a font file newly downloaded from the server (200). At this time, the newly loaded font is applied to the entire application and the user terminal (300).

[0097] During the font loading process, not only the font style but also the font size is loaded. During this process, if the font size needs to be adjusted according to the user's (100) request, the font size is set to a predetermined size or set according to the user's (100) intention.

[0098] Along with the font change, the font size is also updated according to the environment setting change. When the loadSystemFonts() method is called, not only the font style but also the font size is newly applied, and the same font size is applied to UI elements across the user terminal (300).

[0099] At this time, the font size can be forcibly adjusted within a predetermined range, and this setting can affect the entire user terminal (300) or specific UI elements within the application. Consequently, all text UI elements of an application, such as App 1, can be applied with the newly changed font size and style.

[0100] When the new font style and size are successfully loaded via the loadSystemFonts() method, App 1's UI displays text reflecting the newly changed font.

[0101] Text elements throughout the application have the same font size and style, providing consistent usability.

[0102] In this way, a font change can be made by detecting an environment change (font change request) in ConfigurationController.java, processing it, and then applying a new font style and size to the user terminal (300) and the entire application through the SandollTypeface.loadSystemFonts() method.

[0103] At this time, the font size that is arbitrarily changed can be changed within a predetermined range.

[0104] For example, you can change the font in units smaller than the font size change unit.

[0105] In this condition, the font size change range is set to a smaller unit than the set change unit to minimize the impact of the font size change within a predetermined range.

[0106] Through this, the user (100) barely notices the change in font size visually, but the font size is processed as being forcibly changed on the user terminal (300).

[0107] If the font size change is too large, it may cause visual discomfort to the user (100). Therefore, to avoid such discomfort, the user terminal (300) may adjust the font size very finely within a range smaller than the change unit, thereby changing the size at a visually insignificant level.

[0108] For example, if the general setting is to change the font size in units of 1 point (1pt), the present invention adjusts the font size in units smaller than 1 point (e.g., 0.1pt or 0.05pt). This way, only subtle changes that are not visually perceptible to the user (100) occur, so that even if the change is made, visual discomfort may not occur.

[0109] Alternatively, the range can be determined based on the display size of the computing device.

[0110] In this scenario, the range of font size changes is determined by the display size of the computing device. For example, because the display sizes of devices such as smartphones, tablets, and smart TVs vary, the range of font size changes may vary depending on these sizes.

[0111] Because small font size changes can feel larger on small screens, and the same size changes can barely be felt on large screens, it's necessary to adjust the font size change range to suit the screen size.

[0112] Since the degree of perceived visual change varies depending on the display size, the user terminal (300) can reduce the visual impact by adjusting the font size change within a fine range based on the display size.

[0113] For example, on a small display (like a smartphone), a change of 0.5pt can be perceived as significant, so adjustments should be made in smaller increments. On a large display (like a smart TV), however, the same change is barely noticeable, so adjustments can be made in larger increments.

[0114] On smartphones with small displays, subtle changes in font size, such as 0.1pt increments, can create visually insignificant changes. Conversely, on tablets or TVs with large displays, even a 1pt increment may be barely noticeable to the user (100). This allows for optimized changes tailored to each device.

[0115] Additionally, in this embodiment, the user terminal (300) can determine the range according to the settings of the system in which the font size is defined.

[0116] It is also possible to define font sizes using floating point formats and limit the variation of font sizes to the decimal or exponent parts based on this format.

[0117] Floating-point format is a method of representing numbers, offering the advantage of high precision. This format is primarily used to accurately represent large or small numbers, and allows precise control down to the number of decimal places.

[0118] For example, if you set the font size to 10.0 in floating point, you can use the decimal places to make finer adjustments to the size, such as 10.1, 10.01, 10.001, etc.

[0119] The user terminal (300) sets the font size to a floating point and adjusts the font size by changing the value after the decimal point. This enables visually insignificant fine-grained size adjustments and provides subtle size changes so that the user (100) does not perceive the change in font size.

[0120] If a user (100) is using a 10.0pt font and the user terminal (300) needs to adjust it, the font size can be set to a small change below the decimal point, such as 10.01pt or 9.99pt. Such a small change is made in such a small range that the user (100) is hardly aware of the change in font size.

[0121] Specifically, the range can be set in such a way that it restricts changes to the exponent part and only changes the mantissa part.

[0122] Floating point formats divide numbers into an exponent and a mantissa.

[0123] The exponent part determines how many times larger or smaller the number is, and adjusts for large changes.

[0124] The mantissa part is the part that adjusts the detailed values ​​of the number, increasing the precision of the number.

[0125] It prevents large size changes due to changes in the exponent part, and allows for subtle changes in the mantissa part, allowing for font size adjustments without significant visual changes.

[0126] Since the exponent portion is a factor that significantly changes the font size, we limit large changes in font size by leaving it unchanged. Instead, we fine-tune only the mantissa portion to apply only very small changes, so that the font size is barely noticeable to the user (100)'s eyes.

[0127] For example, if your font size is set to 1.23 x 10^1 (i.e. 12.3pt), you can adjust the font size to something like 1.2301 x 10^1 or 1.2299 x 10^1 by changing only the mantissa (1.23) and not the exponent (10^1). This changes only the mantissa while maintaining the exponent, so the size change is subtle and may be barely perceptible visually.

[0128] Because floating-point formats can express numbers with high precision, down to the decimal point, they allow for very fine adjustments to font sizes. This has the advantage of providing users (100) with visually insignificant changes.

[0129] The present invention prevents large changes in font size by limiting changes to the exponent portion, and only adjusts the mantissa portion to ensure only subtle changes occur. This ensures that even if the font size is forcibly adjusted, the changes are handled as minor changes that are not noticeable to the user (100).

[0130] Floating point format allows for precise sizing based on display resolution or device characteristics, allowing you to set the optimal font size for various display environments.

[0131] The ideal user terminal (300) adjusts the font size appropriately to suit the user's (100) device environment, thereby ensuring that the same font style and size are applied across each application. In this process, even if the user (100) does not intend it, the font style across all applications changes as a result of the font size change.

[0132] Next, the user terminal (300) changes the existing font to a new font style and size according to the font style and size change command (S400). This change is applied to the entire user terminal (300), and the new font is reflected throughout the OS and application UI.

[0133] FIG. 6 is a flowchart illustrating a process of readjusting the size of an arbitrarily changed font according to one embodiment of the present invention.

[0134] Referring to FIG. 6, the user terminal (300) can request to change the new size back to the existing font size (S500).

[0135] The present invention includes a process of restoring the font size to its original setting to ensure stability and ease of use of the user terminal (300), even if the font size is arbitrarily changed slightly.

[0136] Even when adjusting the font size within a very small range below the decimal point, or when using a floating-point format to make subtle changes to only the mantissa while maintaining the exponent, the user (100) may be configured to not visually perceive these changes. However, even such subtle changes may compromise the stability of the user terminal (300) or cause inconvenience to the user (100).

[0137] Accordingly, the present invention includes a step of restoring the font size to its original size upon a request from a user (100) or an automatic restoration condition after the font size has been changed. This is intended to minimize the impact of any font size change on the UI of the user terminal (300) or application, ensure the stability of the user terminal (300) through restoration to the original setting, and optimize usability.

[0138] Even if the font size is changed slightly, it is processed as a visually meaningless change to the user (100), and the change is applied to the user terminal (300) without a large visual change.

[0139] If the changed font size causes inconvenience to the user (100) or interferes with the UI layout, the user terminal (300) can automatically or manually revert to the original font size. This maintains consistency in the user (100) environment and enhances the stability of the user terminal (300).

[0140] Since the settings prior to changing the font size are remembered, the font size prior to the change can be quickly restored when the user (100) requests a return. This allows the user (100) to use the user terminal (300) stably and without inconvenience.

[0141] When the changed font size is restored, the text in the UI and application is properly positioned, readability is improved, and usability is maintained consistently.

[0142] Therefore, the purpose of the present invention is to ensure system stability and user (100) satisfaction by applying a fine change in font size to the entire system, and by restoring it to the original size when necessary.

[0143] The present invention, as described above, aims to address the problem of font styles and sizes not being consistently applied across multiple applications installed on a smartphone. The present invention provides a unified font environment to the user (100) by inducing each application to follow the font settings of the operating system. This allows for consistent user convenience while simultaneously enhancing design integration across applications.

[0144] FIG. 7 is an exemplary diagram showing the implementation of a server as a computing device according to the present embodiment.

[0145] Referring to FIG. 7, in some embodiments of the present invention, a user terminal (300) may be implemented in the form of a computing device. One or more of each module constituting the user terminal (300) is implemented on a general-purpose computing processor and may therefore include a processor (308), an input / output I / O (302), a memory (304), an interface (306), and a bus (314). The processor (308), the input / output device (302), the memory (304), and / or the interface (306) may be coupled to each other via a bus (305). The bus (314) corresponds to a path through which data is transferred.

[0146] Specifically, the processor (308) may include at least one of a CPU (Central Processing Unit), an MPU (Micro Processor Unit), an MCU (Micro Controller Unit), a GPU (Graphics Processing Unit), a microprocessor, a digital signal processor, a microcontroller, an application processor (AP), and logic elements capable of performing functions similar thereto.

[0147] The input / output device (302) may include at least one of a keypad, a keyboard, a touchscreen, and a display device. The memory device (304) may store data and / or programs, etc.

[0148] The interface (306) may perform a function of transmitting data to or receiving data from a communication network. The interface (306) may be wired or wireless. For example, the interface (306) may include an antenna or a wired / wireless transceiver. The memory (304) may further include high-speed DRAM and / or SRAM as a volatile operating memory for enhancing the operation of the processor (308) and protecting personal information.

[0149] Additionally, the memory (304) stores programming and data configurations that provide the functionality of some or all of the modules described herein. For example, it may include logic for performing selected aspects of the learning method described above.

[0150] Furthermore, the various embodiments described herein may be implemented in a recording medium readable by a computer or similar device, for example, using software, hardware, or a combination thereof.

[0151] In terms of hardware implementation, the embodiments described herein can be implemented using at least one of ASICs (application specific integrated circuits), DSPs (digital signal processors), DSPDs (digital signal processing devices), PLDs (programmable logic devices), FPGAs (field programmable gate arrays), processors, controllers, micro-controllers, microprocessors, and other electrical units for performing functions. In some cases, the embodiments described herein can be implemented as a control module itself.

[0152] In a software implementation, the embodiments described herein, such as the procedures and functions, may be implemented as separate software modules. Each of the software modules may perform one or more of the functions and operations described herein. The software code may be implemented as a software application written in a suitable programming language. The software code may be stored in a memory module and executed by a control module.

[0153] The above description is merely an example of the technical idea of ​​the present invention, and those skilled in the art will appreciate that various modifications, changes, and substitutions can be made without departing from the essential characteristics of the present invention.

[0154] Accordingly, the embodiments disclosed in the present invention and the accompanying drawings are intended to illustrate, rather than limit, the technical concept of the present invention, and the scope of the technical concept of the present invention is not limited by these embodiments and the accompanying drawings. The protection scope of the present invention should be interpreted by the following claims, and all technical concepts within the scope equivalent thereto should be interpreted as being included within the scope of the rights of the present invention.

Claims

1. In a method for changing a font performed on a computing device, Step of receiving a user's request to change font; A step of requesting a change to a new font based on the input font change request; A step of requesting a change to the font size of an existing font to a new size within a predetermined range along with a request for a change to the above new font; and Including a step of changing the existing font to a new font according to the new size according to the above request, How to change font.

2. In paragraph 1, The above predetermined range is, A unit smaller than the change unit set for the above font size, How to change font.

3. In paragraph 1, The above predetermined range is, Depending on the display size of the computing device, How to change font.

4. In paragraph 1, Including a step of requesting to change the above new size back to the existing font size, How to change font.

5. In paragraph 4, The above font size is set in floating point format, The above predetermined range is determined to change the size of the decimal point, How to change font.

6. In paragraph 5, The above predetermined range is determined so that the mantissa part is changed within a range in which the change of the exponent part defining the above font size is limited. How to change font.

7. Processor, and including a memory communicating with the processor, The above memory stores instructions that cause the processor to perform operations, The above actions are, Action to receive user's request to change font, An action to request a change to a new font based on the font change request entered above. An action to request a change to the font size of an existing font to a new size within a predetermined range along with a request to change to the above new font, and Including an action of changing an existing font to a new font according to the new size according to the above request, Computer devices.

8. In paragraph 7, The above predetermined range is, A unit smaller than the change unit set for the above font size, Computer devices.

9. In paragraph 7, The above predetermined range is, Depending on the display size of the computing device, Computer devices.

10. In paragraph 7, Including an action to request that the above new size be changed back to the existing font size, Computer devices.

11. In paragraph 10, The above font size is set in floating point format, The above predetermined range is determined to change the size of the decimal point, Computer devices.

12. In paragraph 11, The above predetermined range is determined so that the mantissa part is changed within a range in which the change of the exponent part defining the above font size is limited. Computer devices.

Images